1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 // This harness reqires a writeable drive other than C: or Z:, e.g. an MMC drive

    17 

    18 #include <e32test.h>

    19 #include "T_UTILS.H"

    20 #include "CContactDbEventQueue.h"

    21 #include <coreappstest/testserver.h>

    22 

    23 // Type definitions 

    24 LOCAL_D RTest test(_L("T_ERROR"));

    25 LOCAL_D RFs TheFs;

    26 LOCAL_D CContactIdArray* IdList;

    27 

    28 enum TOomFailureModes

    29 	{	

    30 	KOomFailNormal,

    31 	KOomFailFileServerGeneral,

    32 	KOomFailFileServerOom,

    33 	KOomFailContactServer,

    34 	KOomFailDbs,

    35 	KOomNumFailModes,

    36 	};	

    37 

    38 const TPtrC KDatabaseFileName = _L("C:T_ERROR");

    39 const TPtrC KDatabaseCreateFileName = _L("C:T_ERRORC");

    40 const TPtrC KFakeFDrive=_L("C:FAKEFDRIVE");

    41 

    42 typedef TBuf<0x40> TOomTestName;

    43 

    44 class COomTest;

    45 

    46 class COomFailBase : public CBase

    47 	{

    48 public:

    49 	~COomFailBase();

    50 	COomFailBase(COomTest* aOomTest);

    51 	virtual void ConstructL();

    52 	virtual void PreFailL();

    53 	virtual void ClearUpL();

    54 	virtual void FailL() = 0;

    55 	virtual TBool ErrorOk(TOomFailureModes aMode, TInt aIteration, TInt aError);

    56 	virtual TOomTestName TestName() = 0;

    57 	virtual TBool Skip(TInt aCount, TOomFailureModes aMode) const;

    58 protected:

    59 	void RecoverL(TBool waitForEvent = EFalse); 

    60 	void WaitForEvent(TContactDbObserverEventType anEventType);

    61 

    62 protected:

    63 	COomTest* iOomTest;

    64 	CContactDatabase* iDb;

    65 	CContactDbEventQueue* iDbEventQueue;

    66 	TInt iCounter;

    67 	};

    68 

    69 class COomOpen : public COomFailBase

    70 	{

    71 public:

    72 	inline COomOpen(COomTest* aOomTest) : COomFailBase(aOomTest) {};

    73 	void FailL();

    74 	void ClearUpL();

    75 	inline TOomTestName TestName() {return(_L("Open"));};

    76 private:

    77 	CContactDatabase* iDb2;

    78 	CContactDatabase* iDb;

    79 	};

    80 

    81 class COomCreate : public COomFailBase

    82 	{

    83 public:

    84 	inline COomCreate(COomTest* aOomTest) : COomFailBase(aOomTest) {};

    85 	inline TOomTestName TestName() {return(_L("Create"));};

    86 	void PreFailL();

    87 	void FailL();

    88 	void ClearUpL();

    89 private:

    90 	CContactDatabase* iDb2;

    91 	};

    92 

    93 class COomSetDatabaseDrive : public COomFailBase

    94 	{

    95 public:

    96 	inline COomSetDatabaseDrive(COomTest* aOomTest, TDriveUnit aMmcDrive) : COomFailBase(aOomTest), iMmcDrive(aMmcDrive) {};

    97 	inline TOomTestName TestName() {return(_L("SetDatabaseDrive"));};

    98 	void PreFailL();

    99 	void ConstructL();

   100 	void FailL();

   101 	void ClearUpL();

   102 	TBool ErrorOk(TOomFailureModes aMode, TInt aIteration, TInt aError);

   103 private:

   104 	// writeable drive found for testing with

   105 	TDriveUnit iMmcDrive;

   106 	};

   107 

   108 class COomGetDefaultName : public COomFailBase

   109 	{

   110 public:

   111 	inline COomGetDefaultName(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   112 	inline TOomTestName TestName() {return(_L("GetDefaultName"));};

   113 	void FailL();

   114 	};

   115 

   116 class COomViewDefinition : public COomFailBase

   117 	{

   118 public:

   119 	inline COomViewDefinition(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   120 	inline TOomTestName TestName() {return(_L("ViewDefinition"));};

   121 	void FailL();

   122 	};

   123 

   124 class COomTextDefinition : public COomFailBase

   125 	{

   126 public:

   127 	inline COomTextDefinition(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   128 	inline TOomTestName TestName() {return(_L("TextDefinition"));};

   129 	void FailL();

   130 	};

   131 

   132 class COomReadContact : public COomFailBase

   133 	{

   134 public:

   135 	inline COomReadContact(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   136 	inline TOomTestName TestName() {return(_L("ReadContact"));};

   137 	void FailL();

   138 	};

   139 

   140 class COomAddNewContact : public COomFailBase

   141 	{

   142 public:

   143 	inline COomAddNewContact(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   144 	inline TOomTestName TestName() {return(_L("AddNewContact"));};

   145 	void PreFailL();

   146 	void FailL();

   147 	void ClearUpL();

   148 	TBool Skip(TInt aCount, TOomFailureModes aMode) const;

   149 protected:

   150 	TContactItemId iNewContactId;

   151 	};

   152 

   153 class COomReadContactTextDef : public COomFailBase

   154 	{

   155 public:

   156 	inline COomReadContactTextDef(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   157 	inline TOomTestName TestName() {return(_L("ReadContactTextDef"));};

   158 	void FailL();

   159 	};

   160 

   161 class COomOpenAndCloseContact : public COomFailBase

   162 	{

   163 public:

   164 	inline COomOpenAndCloseContact(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   165 	inline TOomTestName TestName() {return(_L("OpenAndCloseContact"));};

   166 	void FailL();

   167 	};

   168 

   169 class COomOpenAndCloseContactX : public COomFailBase

   170 	{

   171 public:

   172 	inline COomOpenAndCloseContactX(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   173 	inline TOomTestName TestName() {return(_L("OpenAndCloseContactX"));};

   174 	void FailL();

   175 	};

   176 

   177 class COomOpenModifyAndCommitContact : public COomFailBase

   178 	{

   179 public:

   180 	inline COomOpenModifyAndCommitContact(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   181 	inline TOomTestName TestName() {return(_L("OpenModifyAndCommitContact"));};

   182 	void PreFailL();

   183 	void FailL();

   184 	void ClearUpL();

   185 	TBool Skip(TInt aCount, TOomFailureModes aMode) const;

   186 private:

   187 	CContactItem* iCard;

   188 	};

   189 

   190 class COomDeleteContact : public COomFailBase

   191 	{

   192 public:

   193 	inline COomDeleteContact(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   194 	inline TOomTestName TestName() {return(_L("DeleteContact"));};

   195 	void PreFailL();

   196 	void FailL();

   197 	void ClearUpL();

   198 	TBool Skip(TInt aCount, TOomFailureModes aMode) const;

   199 private:

   200 	TContactItemId iNewContactId;

   201 	TInt iStartCount;

   202 	};

   203 

   204 class COomDeleteContacts : public COomFailBase

   205 	{

   206 public:

   207 	inline COomDeleteContacts(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   208 	inline TOomTestName TestName() {return(_L("DeleteContacts"));};

   209 	void PreFailL();

   210 	void FailL();

   211 	void ClearUpL();

   212 	TBool Skip(TInt aCount, TOomFailureModes aMode) const;

   213 private:

   214 	CContactIdArray* iNewContactIds;

   215 	TInt iStartCount;

   216 	};

   217 

   218 class COomCompact : public COomFailBase

   219 	{

   220 public:

   221 	inline COomCompact(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   222 	inline TOomTestName TestName() {return(_L("Compact"));};

   223 	void FailL();

   224 	void ClearUpL();

   225 	};

   226 

   227 class COomImportContacts : public COomFailBase

   228 	{

   229 public:

   230 	~COomImportContacts();

   231 	void ConstructL();

   232 	inline COomImportContacts(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   233 	inline TOomTestName TestName() {return(_L("ImportContacts"));};

   234 	void PreFailL();

   235 	void FailL();

   236 	void ClearUpL();

   237 	TBool Skip(TInt aCount, TOomFailureModes aMode) const;

   238 private:

   239 	CFileStore* iStore;

   240 	RStoreReadStream iInStream;

   241 	TStreamId iStreamId;

   242 	CArrayPtr<CContactItem>* iImportedContacts;

   243 	TInt iOldRecordCount;

   244 	TContactItemId iDeleteMeId;

   245 	};

   246 

   247 class COomExportSelectedContacts : public COomFailBase

   248 	{

   249 public:

   250 	~COomExportSelectedContacts();

   251 	void ConstructL();

   252 	inline COomExportSelectedContacts(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   253 	inline TOomTestName TestName() {return(_L("ExportSelectedContacts"));};

   254 	void PreFailL();

   255 	void FailL();

   256 	void ClearUpL();

   257 	TBool ErrorOk(TOomFailureModes aMode, TInt aIteration, TInt aError);

   258 private:

   259 	CContactIdArray* iIdList;

   260 	CFileStore* iStore;

   261 	RStoreWriteStream iOutStream;

   262 	TStreamId iStreamId;

   263 	};

   264 

   265 class COomFind : public COomFailBase

   266 	{

   267 public:

   268 	inline COomFind(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   269 	inline TOomTestName TestName() {return(_L("Find"));};

   270 	void FailL();

   271 	};

   272 

   273 class COomFindInTextDef : public COomFailBase

   274 	{

   275 public:

   276 	inline COomFindInTextDef(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   277 	~COomFindInTextDef();

   278 	void ConstructL();

   279 	inline TOomTestName TestName() {return(_L("Find In TextDef"));};

   280 	void FailL();

   281 private:

   282 	CDesCArrayFlat* iFindWords;

   283 	CContactTextDef* iTextDef;

   284 	};

   285 

   286 class COomFindAsyncInTextDef : public COomFailBase

   287 	{

   288 public:

   289 	inline COomFindAsyncInTextDef(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   290 	~COomFindAsyncInTextDef();

   291 	void ConstructL();

   292 	inline TOomTestName TestName() {return(_L("Find In TextDef ASync"));};

   293 	void FailL();

   294 private:

   295 	CDesCArrayFlat* iFindWords;

   296 	CContactTextDef* iTextDef;

   297 	};

   298 

   299 class COomFindAsync : public COomFailBase

   300 	{

   301 public:

   302 	inline COomFindAsync(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   303 	inline TOomTestName TestName() {return(_L("FindAsync"));};

   304 	void FailL();

   305 	};

   306 

   307 class COomSort : public COomFailBase

   308 	{

   309 public:

   310 	inline COomSort(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   311 	inline TOomTestName TestName() {return(_L("Sort"));};

   312 	void FailL();

   313 	TBool Skip(TInt aCount, TOomFailureModes aMode) const;

   314 private:

   315 	TInt iPrevCount;

   316 	};

   317 

   318 class COomSortArray : public COomFailBase

   319 	{

   320 public:

   321 	~COomSortArray();

   322 	inline COomSortArray(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   323 	inline TOomTestName TestName() {return(_L("Sort Array"));};

   324 	void ConstructL();

   325 	void FailL();

   326 private:

   327 	CContactIdArray* iIdArray;

   328 	TInt iPrevCount;

   329 	CArrayFix<CContactDatabase::TSortPref>* iSortOrder;

   330 	};

   331 

   332 class COomCompress : public COomFailBase, public MContactUiCompactObserver

   333 	{

   334 public:

   335 	inline COomCompress(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   336 	inline TOomTestName TestName() {return(_L("Compress"));};

   337 	void PreFailL();

   338 	void FailL();

   339 	TBool Skip(TInt aCount, TOomFailureModes aMode) const;

   340 	void ClearUpL();

   341 // from MContactUiCompactObserver

   342 	void Step(TInt aStep);

   343 	void HandleError(TInt aError);

   344 private:

   345 	TInt iRecievedError;

   346 	};

   347 

   348 class COomRecover : public COomFailBase, public MContactUiCompactObserver

   349 	{

   350 public:

   351 	inline COomRecover(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   352 	inline TOomTestName TestName() {return(_L("Recover"));};

   353 	void PreFailL();

   354 	void FailL();

   355 	TBool Skip(TInt aCount, TOomFailureModes aMode) const;

   356 private:

   357 	void doRecoverL();

   358 // from MContactUiCompactObserver

   359 	void Step(TInt aStep);

   360 	void HandleError(TInt aError);

   361 private:

   362 	TInt iRecievedError;

   363 	};

   364 

   365 class COomCloseOpenTables : public COomFailBase

   366 	{

   367 public:

   368 	inline COomCloseOpenTables(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   369 	inline TOomTestName TestName() {return(_L("CloseOpenTables"));};

   370 	void FailL();

   371 	};

   372 

   373 class COomViewDefInternalize : public COomFailBase

   374 	{

   375 public:

   376 	~COomViewDefInternalize();

   377 	inline COomViewDefInternalize(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   378 	inline TOomTestName TestName() {return(_L("ViewDefInternalize"));};

   379 	void ConstructL();

   380 	void PreFailL();

   381 	void FailL();

   382 	void ClearUpL();

   383 protected:

   384 	CBufStore *iBufStore;

   385 	RStoreReadStream iReadStream;

   386 	TStreamId iStreamId;

   387 	};

   388 

   389 class COomViewDefExternalize : public COomFailBase

   390 	{

   391 public:

   392 	~COomViewDefExternalize();

   393 	inline COomViewDefExternalize(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   394 	inline TOomTestName TestName() {return(_L("ViewDefExternalize"));};

   395 	void ConstructL();

   396 	void PreFailL();

   397 	void FailL();

   398 	void ClearUpL();

   399 protected:

   400 	CBufStore* iBufStore;

   401 	RStoreWriteStream iWriteStream;

   402 	TStreamId iStreamId;

   403 	TBool iFailed;

   404 	};

   405 

   406 class COomContactChangeNotifier : public COomFailBase

   407 	{

   408 public:

   409 	class COomNotificationRec : public CBase, public MContactDbObserver

   410 		{

   411 	public:

   412 		static COomNotificationRec* NewL();

   413 		~COomNotificationRec();

   414 		void Wait(TBool aUnknownErrAllowed);

   415 		static TInt TimerCallBackL(TAny* aSelf);

   416 		inline TBool UnknownChange() const {return(iUnknownChange);};

   417 	public: // from MContactDbObserver

   418 		void HandleDatabaseEventL(TContactDbObserverEvent aEvent);

   419 	private:

   420 		void ConstructL();

   421 	private:

   422 		CPeriodic* iTimer;

   423 		TBool iWaiting;

   424 		TBool iGotMessage;

   425 		TBool iUnknownErrAllowed;

   426 		TBool iUnknownChange;

   427 		};

   428 public:

   429 	~COomContactChangeNotifier();

   430 	inline COomContactChangeNotifier(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   431 	inline TOomTestName TestName() {return(_L("ContactChangeNotifier"));};

   432 	void ConstructL();

   433 	void PreFailL();

   434 	void FailL();

   435 	void ClearUpL();

   436 	TBool Skip(TInt aCount, TOomFailureModes aMode) const;

   437 protected:

   438 	COomNotificationRec* iRec;

   439 	CContactItem* iItem1;

   440 	CContactItem* iItem2;

   441 	CContactItem* iItem3;

   442 	};

   443 

   444 class COomFieldSetStore : public COomFailBase

   445 	{

   446 public:

   447 	~COomFieldSetStore();

   448 	inline COomFieldSetStore(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   449 	inline TOomTestName TestName() {return(_L("FieldSetStore"));};

   450 	void ConstructL();

   451 	void FailL();

   452 	void ClearUpL();

   453 protected:

   454 	CBufStore* iBufStore;

   455 	CBufStore* iBlobStore;

   456 	CBufStore* iTextStore;

   457 	CContactItemFieldSet* iItemFieldSet;

   458 	TStreamId iStreamId;

   459 	};

   460 

   461 class COomFieldSetRestore : public COomFailBase

   462 	{

   463 public:

   464 	~COomFieldSetRestore();

   465 	inline COomFieldSetRestore(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   466 	inline TOomTestName TestName() {return(_L("FieldSetRestore"));};

   467 	void ConstructL();

   468 	void PreFailL();

   469 	void FailL();

   470 	void ClearUpL();

   471 protected:

   472 	CBufStore* iBufStore;

   473 	CBufStore* iTextStore;

   474 	CBufStore* iBlobStore;

   475 	TStreamId iStreamId;

   476 	TStreamId iTextStreamId;

   477 	CContactViewDef* iViewDef;

   478 	};

   479 

   480 class COomContactCardClone : public COomFailBase

   481 	{

   482 public:

   483 	~COomContactCardClone();

   484 	inline COomContactCardClone(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   485 	inline TOomTestName TestName() {return(_L("ContactCardClone"));};

   486 	void ConstructL();

   487 	void FailL();

   488 private:

   489 	CContactCard* iSourceCard;

   490 	};

   491 

   492 class COomPhoneNumberLookup : public COomFailBase

   493 	{

   494 public:

   495 	~COomPhoneNumberLookup();

   496 	inline COomPhoneNumberLookup(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   497 	inline TOomTestName TestName() {return(_L("Phone Number Lookup"));};

   498 	void ConstructL();

   499 	void PreFailL();

   500 	void FailL();

   501 	void ClearUpL();

   502 private:

   503 	TInt FileSizeL();

   504 private:

   505 	TContactItemId iAddId;

   506 	CContactCard* iAddCard;

   507 	};

   508 

   509 class COomContactsChangedSince : public COomFailBase

   510 	{

   511 public:

   512 	~COomContactsChangedSince();

   513 	inline COomContactsChangedSince(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   514 	inline TOomTestName TestName() {return(_L("ContactsChangedSince"));};

   515 	void ConstructL();

   516 	void FailL();

   517 private:

   518 	TContactItemId iNewContactId1;

   519 	TContactItemId iNewContactId2;

   520 	TTime iBeforeTime;

   521 	};

   522 

   523 class COomGroups : public COomFailBase

   524 	{

   525 public:

   526 	~COomGroups();

   527 	inline COomGroups(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   528 	inline TOomTestName TestName() {return(_L("Groups"));};

   529 	void ConstructL();

   530 	void FailL();

   531 	void ClearUpL();

   532 	TBool Skip(TInt aCount, TOomFailureModes aMode) const;

   533 private:

   534 	TContactItemId iGroupId;

   535 	CContactCard* iItem1;

   536 	};

   537 

   538 class COomGroups2 : public COomFailBase

   539 	{

   540 public:

   541 	~COomGroups2();

   542 	inline COomGroups2(COomTest* aOomTest) : COomFailBase(aOomTest) {};

   543 	inline TOomTestName TestName() {return(_L("Groups 2"));};

   544 	void ConstructL();

   545 	void FailL();

   546 	void ClearUpL();

   547 private:

   548 	TContactItemId iGroupId1;

   549 	TContactItemId iGroupId2;

   550 	};

   551 

   552 //

   553 

   554 class COomTest : public CBase

   555 	{

   556 public:

   557 	COomTest(TDriveUnit aMmcDrive);

   558 	void ConstructL();

   559 	~COomTest();

   560 	TBool DoTestL();

   561 	void DoOomTestL(COomFailBase *aOomTest, TOomFailureModes aMode);

   562 	void Test(TBool aMustBeTrue);

   563 	TBool TestsL();

   564 private:

   565 	TInt GetRecordCountL();

   566 private:

   567 	RDbs iDbs;

   568 	TDriveUnit iMmcDrive;

   569 	};

   570 

   571 

   572 LOCAL_C void AddNewContactsL()

   573 //

   574 // Add 2 new contacts with varying numbers of text fields

   575 //

   576 	{

   577 	CContactDatabase* db=CContactDatabase::OpenL(KDatabaseFileName);

   578 	CleanupStack::PushL(db);

   579 	CContactCard* card=CContactCard::NewL();

   580 	CleanupStack::PushL(card);

   581 	TContactItemId id=KNullContactId;

   582 	TContactItemId newId=KNullContactId;

   583 	for (TInt ii=0;ii<5;ii++)

   584 		{

   585 		TBuf<16> name;

   586 		name.Format(_L("NAME #%d"),ii);

   587 		SetNameL(*card,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,name,EFalse);

   588 		name.Format(_L("GivenName #%d"),ii);

   589 		SetNameL(*card,KUidContactFieldGivenName,KUidContactFieldVCardMapUnusedN,name,EFalse);

   590 		CContactItemField* field=CContactItemField::NewLC(KStorageTypeText);

   591 		card->AddFieldL(*field);

   592 		CleanupStack::Pop(); // field

   593 		newId=db->AddNewContactL(*card);

   594 		id=newId;

   595 		IdList->AddL(id);

   596 		}

   597 	CleanupStack::PopAndDestroy(2); // card, db

   598 	}

   599 

   600 LOCAL_C void CreateDatabaseL()

   601 //

   602 // Create a database in a store

   603 //

   604 	{

   605 	CContactDatabase* db=CContactDatabase::ReplaceL(KDatabaseFileName);

   606 	delete db;

   607 	}

   608 

   609 //	

   610 //

   611 // COomFailBase

   612 //

   613 

   614 COomFailBase::COomFailBase(COomTest* aOomTest) : iOomTest(aOomTest), iCounter(0)

   615 	{}

   616 

   617 COomFailBase::~COomFailBase()

   618 	{

   619 	delete iDbEventQueue;

   620 	delete iDb;

   621 	}

   622 

   623 void COomFailBase::ConstructL()

   624 	{

   625 	iDb=CContactDatabase::OpenL(KDatabaseFileName);

   626 	iDbEventQueue = CContactDbEventQueue::NewL(iDb);

   627 	}

   628 

   629 void COomFailBase::WaitForEvent(TContactDbObserverEventType anEventType)

   630 	{

   631 	TContactDbObserverEvent event;

   632 	++iCounter;

   633 	FOREVER

   634 		{

   635 		event.iType = EContactDbObserverEventNull;

   636 		iDbEventQueue->ListenForEvent(1,event);  //1 second timeout

   637 		//RDebug::Print(_L("%d Message: %d"), iCounter, event.iType);

   638 		

   639 		if (event.iType == anEventType || event.iType == EContactDbObserverEventNull)

   640 			break;

   641 		}

   642 	}

   643 

   644 void COomFailBase::PreFailL()

   645 	{}

   646 

   647 void COomFailBase::ClearUpL()

   648 	{}

   649 

   650 TBool COomFailBase::ErrorOk(TOomFailureModes aMode, TInt aIteration, TInt aError)

   651 	{

   652 	if(aMode == KOomFailFileServerGeneral)

   653 		{

   654 		if (aError != KErrGeneral)

   655 			{

   656 			test.Printf(_L("ErrorOk test failed - Mode %i, iteration %i, error %i"), aMode, aIteration, aError);

   657 			return EFalse;

   658 			}

   659 		return ETrue;

   660 		}

   661 	else

   662 		{

   663 		if (aError != KErrNoMemory)

   664 			{

   665 			test.Printf(_L("ErrorOk test failed - Mode %i, iteration %i, error %i"), aMode, aIteration, aError);

   666 			return EFalse;

   667 			}

   668 		return ETrue;

   669 		}

   670 	}

   671 

   672 void COomFailBase::RecoverL(TBool waitForEvent)

   673 	{

   674 	iDb->RecoverL();

   675 	if (waitForEvent)

   676 		{

   677 		WaitForEvent(EContactDbObserverEventRecover);

   678 		}

   679 	else

   680 		{

   681 		iDbEventQueue->Clear();

   682 		}

   683 		

   684 	}

   685 

   686 TBool COomFailBase::Skip(TInt , TOomFailureModes ) const

   687 	{

   688 	// When trying to figure out why we need this, please see DEF037382 and DEF037234

   689 	// Basically, certain conditions cause the DBMS system to corrupt the database

   690 	// and we hop over those particular cases.

   691 	//

   692 	// Generally, one particular case, perhaps when count==71 or whatever, will be

   693 	// the only problem. However, new builds and commenting out other test cases

   694 	// can both change this number, so in a lot of cases every test is skipped instead.

   695 	return(EFalse);

   696 	}

   697 

   698 //

   699 // COomOpen

   700 //

   701 

   702 void COomOpen::FailL()

   703 	{

   704 	iDb2=CContactDatabase::OpenL(KDatabaseFileName);

   705 	iDb2->CountL();

   706 	}

   707 

   708 void COomOpen::ClearUpL()

   709 	{

   710 	RecoverL();

   711 	delete iDb2;

   712 	iDb2=NULL;

   713 	}

   714 

   715 //

   716 // COomCreate

   717 //

   718 

   719 void COomCreate::PreFailL()

   720 	{

   721 	if(CContactDatabase::ContactDatabaseExistsL(KDatabaseCreateFileName))

   722     	CContactDatabase::DeleteDatabaseL(KDatabaseCreateFileName);

   723 	}

   724 

   725 void COomCreate::FailL()

   726 	{

   727 	iDb2=CContactDatabase::CreateL(KDatabaseCreateFileName);

   728 	}

   729 

   730 void COomCreate::ClearUpL()

   731 	{

   732 	RecoverL();

   733 	delete iDb2;

   734 	iDb2=NULL;

   735     TRAPD(err,CContactDatabase::DeleteDatabaseL(KDatabaseCreateFileName));

   736 	if (err != KErrNotFound)

   737 		{

   738 		User::LeaveIfError(err);

   739 		}

   740 	}

   741 

   742 //

   743 // COomSetDatabaseDrive

   744 //

   745 

   746 void COomSetDatabaseDrive::ConstructL()

   747 	{

   748 	COomFailBase::ConstructL();

   749 	CContactDatabase::SetDatabaseDriveL(TDriveUnit(EDriveC),EFalse);

   750 	}

   751 

   752 void COomSetDatabaseDrive::PreFailL()

   753 	{

   754 	// select test drive

   755 	CContactDatabase::SetDatabaseDriveL(iMmcDrive,EFalse);

   756 	// delete default database, if present

   757 	TRAP_IGNORE(CContactDatabase::DeleteDefaultFileL());

   758 	// switch back to C: drive

   759 	CContactDatabase::SetDatabaseDriveL(TDriveUnit(EDriveC),EFalse);

   760 	// ensure a default database file exists on C:

   761 	if (!CContactDatabase::DefaultContactDatabaseExistsL())

   762 		{

   763 		CContactDatabase* newDb = CContactDatabase::ReplaceL();

   764 		delete newDb;

   765 		}

   766 	}

   767 

   768 void COomSetDatabaseDrive::FailL()

   769 	{

   770 	CContactDatabase::SetDatabaseDriveL(iMmcDrive);

   771 	}

   772 

   773 void COomSetDatabaseDrive::ClearUpL()

   774 	{

   775 // Below needed because of problem with CDictionaryStore reporting error when it has successfully

   776 // committed changes to the DatabaseDrive ini variable

   777 	RecoverL();

   778 	

   779 	TRAPD(error,CContactDatabase::SetDatabaseDriveL(TDriveUnit(EDriveC),ETrue));

   780 	if (error==KErrNotFound || error==KErrAlreadyExists)

   781 		{

   782 		CContactDatabase::SetDatabaseDriveL(TDriveUnit(EDriveC),EFalse);

   783 		}

   784 	else 

   785 		{

   786 		User::LeaveIfError(error);

   787 		}

   788 	}

   789 

   790 TBool COomSetDatabaseDrive::ErrorOk(TOomFailureModes aMode, TInt aIteration, TInt aError)

   791 	{

   792 	if(aMode != KOomFailFileServerGeneral)

   793 		{

   794 		if (aError != KErrNoMemory)

   795 			{

   796 			TPtrC drvPtr(iMmcDrive.Name());

   797 

   798 			test.Printf(_L("ErrorOk test failed for SetDatabaseDrive(%S) - Mode %i, iteration %i, error %i"), 

   799 				&drvPtr, aMode, aIteration, aError);

   800 

   801 #ifdef __WINS__

   802 			if (aError == KErrNotReady)

   803 				{

   804 				test.Printf(_L("Writeable directory must map to an extra drive (e.g. F: or D:). In epoc.ini file add _EPOC_DRIVE_F \\epoc32\\winscw\\f"));

   805 				}

   806 			else if (aError == KErrPathNotFound)

   807 				{

   808 				test.Printf(_L("Drive %S mapped in epoc.ini file, but probably the mapped directory does not exist."), &drvPtr);

   809 				}

   810 #else

   811 			// hardware build

   812 			if (aError == KErrNotReady)

   813 				{

   814 				test.Printf(_L("Drive %s not ready."), &drvPtr);

   815 				}

   816 #endif

   817 			return EFalse;

   818 			}

   819 		return ETrue;

   820 		}

   821 	else

   822 		{

   823 		return(COomFailBase::ErrorOk(aMode, aIteration, aError));

   824 		}

   825 	}

   826 

   827 //

   828 // COomGetDefaultName

   829 //

   830 

   831 void COomGetDefaultName::FailL()

   832 	{

   833 	TFileName fileName;

   834 	CContactDatabase::GetDefaultNameL(fileName);

   835 	}

   836 

   837 //

   838 // COomViewDefinition

   839 //

   840 

   841 void COomViewDefinition::FailL()

   842 	{

   843 	CContactItemViewDef* itemViewDef=CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields,CContactItemViewDef::EIncludeHiddenFields);

   844 	itemViewDef->AddL(KUidContactFieldCompanyName);

   845 	CContactViewDef* viewDef=CContactViewDef::NewL(itemViewDef);

   846 	CleanupStack::Pop();	// itemViewDef

   847 	delete viewDef;

   848 	}

   849 

   850 //

   851 // COomTextDefinition

   852 //

   853 

   854 void COomTextDefinition::FailL()

   855 	{

   856 	CContactTextDef *textDef=CContactTextDef::NewLC();

   857 	textDef->AppendL(TContactTextDefItem(KUidContactFieldPhoneNumber));

   858 	CleanupStack::PopAndDestroy();	// textDef

   859 	}

   860 

   861 //

   862 // COomReadContact

   863 //

   864 

   865 void COomReadContact::FailL()

   866 	{

   867 	iDb->ReadContactLC((*IdList)[0]);

   868 	CContactItem* card2=iDb->ReadContactL((*IdList)[1]);

   869 	CleanupStack::PopAndDestroy();	// card1

   870 	delete card2;

   871 	}

   872 

   873 //

   874 // COomAddNewContact

   875 //

   876 void COomAddNewContact::PreFailL()

   877 	{

   878 	iDbEventQueue->Flush();

   879 	iNewContactId=KNullContactId;

   880 	}

   881 

   882 void COomAddNewContact::FailL()

   883 	{

   884 	CContactCard* card=CContactCard::NewL();

   885 	CleanupStack::PushL(card);

   886 	SetNameL(*card,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("OOM"),EFalse);

   887 	iNewContactId=iDb->AddNewContactL(*card);

   888 	CleanupStack::PopAndDestroy(); // card

   889 	}

   890 

   891 void COomAddNewContact::ClearUpL()

   892 	{

   893 	RecoverL(ETrue); //Wait for recover complete

   894 

   895 	if (iNewContactId!=KNullContactId)

   896 		iDb->DeleteContactL(iNewContactId);

   897 	}

   898 

   899 TBool COomAddNewContact::Skip(TInt aCount, TOomFailureModes aMode) const

   900 	{

   901 	// Skipped because KErrCorrupt when recovering.

   902 	if (aMode==KOomFailFileServerGeneral) return aCount==10;

   903 	if (aMode==KOomFailFileServerOom) return aCount==10;

   904 	return EFalse;

   905 	}

   906 

   907 //

   908 // COomReadContactTextDef

   909 //

   910 

   911 void COomReadContactTextDef::FailL()

   912 	{

   913 	CContactTextDef *textDef=CContactTextDef::NewLC();

   914 	textDef->AppendL(TContactTextDefItem(KUidContactFieldGivenName,_L("==")));

   915 	textDef->AppendL(TContactTextDefItem(KUidContactFieldFamilyName,_L(", ")));

   916 	TBuf<0x100> buf;

   917 	iDb->ReadContactTextDefL((*IdList)[1],buf,textDef);

   918 	iDb->ReadContactTextDefL((*IdList)[3],buf,textDef);

   919 	CleanupStack::PopAndDestroy();	// textDef

   920 	}

   921 

   922 //

   923 // COomOpenAndCloseContact

   924 //

   925 

   926 void COomOpenAndCloseContact::FailL()

   927 	{

   928 	CContactItem* card=iDb->OpenContactL((*IdList)[0]);

   929 	delete card;

   930 	iDb->CloseContactL((*IdList)[0]);

   931 	}

   932 

   933 //

   934 // COomOpenAndCloseContactX

   935 //

   936 

   937 void COomOpenAndCloseContactX::FailL()

   938 	{

   939 	CContactItem* card=iDb->OpenContactLX((*IdList)[0]);

   940 	CleanupStack::PushL(card);

   941 	CleanupStack::PushL(HBufC::NewL(10));	// any old alloc to trigger a fail between the open and close

   942 	iDb->CloseContactL((*IdList)[0]);

   943 	CleanupStack::PopAndDestroy(2); // HBufC & card

   944 	CleanupStack::Pop(); // card close

   945 	}

   946 

   947 //

   948 // COomOpenModifyAndCommitContact

   949 //

   950 

   951 void COomOpenModifyAndCommitContact::PreFailL()

   952 	{

   953 	iCard=iDb->OpenContactL((*IdList)[1]);

   954 	iDbEventQueue->Flush();

   955 	}

   956 

   957 void COomOpenModifyAndCommitContact::FailL()

   958 	{

   959 	SetNameL(*iCard,KUidContactFieldGivenName,KUidContactFieldVCardMapUnusedN,_L("Hacked name"),EFalse);

   960 	iDb->CommitContactL(*iCard);

   961 	}

   962 

   963 void COomOpenModifyAndCommitContact::ClearUpL()

   964 	{

   965 	iDb->CloseContactL((*IdList)[1]);

   966 	delete iCard;

   967 	RecoverL(ETrue); //wait for event

   968 	}

   969 

   970 TBool COomOpenModifyAndCommitContact::Skip(TInt aCount, TOomFailureModes aMode) const

   971 	{

   972 	// KErrCorrupt when recovering

   973 	if (aMode==KOomFailFileServerGeneral) return aCount==11;

   974 	if (aMode==KOomFailFileServerOom) return aCount==11;

   975 	return(EFalse);

   976 	}

   977 

   978 //

   979 // COomDeleteContact

   980 //

   981 

   982 void COomDeleteContact::PreFailL()

   983 	{

   984 	iStartCount=iDb->CountL();

   985 	CContactCard* card=CContactCard::NewL();

   986 	CleanupStack::PushL(card);

   987 	SetNameL(*card,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("DeleteMe"),EFalse);

   988 	iNewContactId=iDb->AddNewContactL(*card);

   989 	CleanupStack::PopAndDestroy(); // card

   990 	}

   991 

   992 void COomDeleteContact::FailL()

   993 	{

   994 	iDb->DeleteContactL(iNewContactId);

   995 	}

   996 

   997 void COomDeleteContact::ClearUpL()

   998 	{

   999 	RecoverL();

  1000 	TRAP_IGNORE(iDb->DeleteContactL(iNewContactId));

  1001 	test(iStartCount==iDb->CountL());

  1002 	}

  1003 

  1004 TBool COomDeleteContact::Skip(TInt aCount, TOomFailureModes aMode) const

  1005 	{

  1006 	// KErrCorrupt when recovering.

  1007 	if (aMode==KOomFailFileServerGeneral) return aCount==11;

  1008 	if (aMode==KOomFailFileServerOom) return aCount==11;

  1009 	return(EFalse);

  1010 	}

  1011 

  1012 //

  1013 // COomDeleteContacts

  1014 //

  1015 

  1016 void COomDeleteContacts::PreFailL()

  1017 	{

  1018 	iStartCount=iDb->CountL();

  1019 	CContactCard* card=CContactCard::NewL();

  1020 	CleanupStack::PushL(card);

  1021 	SetNameL(*card,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("DeleteMe"),EFalse);

  1022 	iNewContactIds=CContactIdArray::NewL();

  1023 	iNewContactIds->AddL(iDb->AddNewContactL(*card));

  1024 	iNewContactIds->AddL(iDb->AddNewContactL(*card));

  1025 	iNewContactIds->AddL(iDb->AddNewContactL(*card));

  1026 	CleanupStack::PopAndDestroy(); // card

  1027 	}

  1028 

  1029 void COomDeleteContacts::FailL()

  1030 	{

  1031 	iDb->DeleteContactsL(*iNewContactIds);

  1032 	}

  1033 

  1034 void COomDeleteContacts::ClearUpL()

  1035 	{

  1036 	RecoverL();

  1037 	for(TInt loop=0;loop<iNewContactIds->Count();loop++)

  1038 		{

  1039 		TRAP_IGNORE(iDb->DeleteContactL((*iNewContactIds)[loop]));

  1040 		}

  1041 	delete iNewContactIds;

  1042 	test(iStartCount==iDb->CountL());

  1043 	}

  1044 

  1045 TBool COomDeleteContacts::Skip(TInt /*aCount*/, TOomFailureModes aMode) const

  1046 	{

  1047 	// KErrCorrupt when recovering.

  1048 	// This fails on one test case (usually around 60 - 70) but which

  1049 	// one changes between builds.

  1050 	if (aMode==KOomFailFileServerGeneral) return ETrue;

  1051 	if (aMode==KOomFailFileServerOom) return ETrue;

  1052 	return EFalse;

  1053 	}

  1054 

  1055 //

  1056 // COomCompact

  1057 //

  1058 

  1059 void COomCompact::FailL()

  1060 	{

  1061 	iDb->CompactL();

  1062 	}

  1063 

  1064 void COomCompact::ClearUpL()

  1065 	{

  1066 	RecoverL();

  1067 	}

  1068 

  1069 //

  1070 // COomExportSelectedContacts

  1071 //

  1072 

  1073 COomExportSelectedContacts::~COomExportSelectedContacts()

  1074 	{

  1075 	delete iIdList;

  1076 	}

  1077 

  1078 void COomExportSelectedContacts::ConstructL()

  1079 	{

  1080 	COomFailBase::ConstructL();

  1081 //

  1082 	CArrayFix<CContactDatabase::TSortPref>* sortOrder=new(ELeave) CArrayFixFlat<CContactDatabase::TSortPref>(3);

  1083 	CleanupStack::PushL(sortOrder);

  1084 	sortOrder->AppendL(CContactDatabase::TSortPref(KUidContactFieldFamilyName));

  1085 	iDb->SortL(sortOrder);

  1086 	CleanupStack::Pop(); // sortOrder

  1087 //

  1088 	iIdList=CContactIdArray::NewL(iDb->SortedItemsL());

  1089 	while(iIdList->Count()>2)

  1090 		iIdList->Remove(0);	// only leave 2 in the array

  1091 	}

  1092 

  1093 void COomExportSelectedContacts::PreFailL()

  1094 	{

  1095 	iStore=CDirectFileStore::ReplaceL(TheFs,_L("c:\\TErrorExport"),EFileWrite);

  1096    	iStore->SetTypeL(KDirectFileStoreLayoutUid);

  1097 	iStreamId=iOutStream.CreateL(*iStore);

  1098 	}

  1099 

  1100 void COomExportSelectedContacts::FailL()

  1101 	{

  1102    	iDb->ExportSelectedContactsL(TUid::Uid(KUidVCardConvDefaultImpl),*iIdList,iOutStream,CContactDatabase::ETTFormat);

  1103 	}

  1104 

  1105 void COomExportSelectedContacts::ClearUpL()

  1106 	{

  1107 	RecoverL();

  1108 	iOutStream.CommitL();

  1109 	iStore->SetRootL(iStreamId);

  1110 	iStore->CommitL();  	

  1111 	iOutStream.Close();

  1112 	delete iStore;

  1113 	}

  1114 

  1115 TBool COomExportSelectedContacts::ErrorOk(TOomFailureModes aMode, TInt aIteration, TInt aError)

  1116 	{

  1117 	// LoadPluginL interprets all file server errors as KErrNotFound, except KErrNoMemory.

  1118 	if(aMode == KOomFailFileServerGeneral)

  1119 		{

  1120 		if (aError == KErrGeneral || aError == KErrNotFound)

  1121 			return ETrue;

  1122 		

  1123 		test.Printf(_L("ErrorOk test - Mode %i, iteration %i, error %i"), aMode, aIteration, aError);

  1124 		return EFalse;

  1125 		}

  1126 	else if(aMode == KOomFailFileServerOom)

  1127 		{

  1128 		if (aError == KErrNoMemory || aError == KErrNotFound)

  1129 			return ETrue;

  1130 

  1131 		test.Printf(_L("ErrorOk test - Mode %i, iteration %i, error %i"), aMode, aIteration, aError);

  1132 		return EFalse;

  1133 		}

  1134 	else