1 // Copyright (c) 2001-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 #include <cntview.h>

    17 #include "cntviewprivate.h"

    18 #include "t_utils2.h"

    19 

    20 

    21 //

    22 // Forward declarations.

    23 //

    24 

    25 class CSortChecker;

    26 class CTestBase;

    27 class CViewCreator;

    28 class CContactAdder;

    29 class CContactRemover;

    30 class CViewExerciser;

    31 class CSortOrderChanger;

    32 class CContactDbEventQueue;

    33 

    34 enum TOomFailureModes

    35 	{

    36 	KOomFailNormal,

    37 	KOomFailFileServerGeneral,

    38 	KOomFailFileServerOom,

    39 	KOomFailContactServer,

    40 	KOomNumFailModes,

    41 	};

    42 

    43 const TInt KNumContactsInGroupOne=27;

    44 _LIT(KGroupOneName,"GroupOne");

    45 

    46 typedef TBuf<0x40> TOomTestName;

    47 

    48 //

    49 // CTestConductor.

    50 //

    51 

    52 class CTestConductor : public CActive, public MContactViewObserver

    53 	{

    54 public:

    55 	static CTestConductor* NewL();

    56 	~CTestConductor();

    57 	void NextTest();

    58 private:

    59 	CTestConductor();

    60 	void ConstructL();

    61 private: // From CActive.

    62 	void RunL();

    63 	TInt RunError(TInt aError);

    64 	void DoCancel();

    65 private: // From MContactViewObserver.

    66 	virtual void HandleContactViewEvent(const CContactViewBase& aView,const TContactViewEvent& aEvent);

    67 private:

    68 	enum TTest

    69 		{

    70 		ECreateLocalView,

    71 		EAddInitialContacts,

    72 		EAddGroup,

    73 		ECreateRemoteView,

    74 		EDoOOMTests,

    75 		ENumTests

    76 		};

    77 public:

    78 	RTest iTest;

    79 	RFs iFs;

    80 	CLog* iLog;

    81 	CContactDatabase* iDb;

    82 	CSortChecker* iSortChecker;

    83 	RContactViewSortOrder iSortOrder_1;

    84 	RContactViewSortOrder iSortOrder_2;

    85 	CContactLocalView* iLocalView;

    86 	CContactRemoteView* iRemoteView_1;

    87 private:

    88 	CViewCreator* iViewCreator;

    89 	CContactAdder* iContactAdder;

    90 	CContactRemover* iContactRemover;

    91 	CViewExerciser* iViewExerciser;

    92 	CSortOrderChanger* iSortOrderChanger;

    93 	TInt iCurrentTestNumber;

    94 	CTestBase* iCurrentTestObject;

    95 	TBool iGnoreNotifications;

    96 	CContactGroup* iGroupOne;

    97 	TContactItemId iGroupId;

    98 	TInt iTestError;

    99 	};

   100 

   101 

   102 //

   103 // CSortChecker.

   104 //

   105 

   106 class CSortChecker : public CBase

   107 	{

   108 public:

   109 	enum TSortOrder

   110 		{

   111 		EFirstNameLastName,

   112 		ELastNameFirstName

   113 		};

   114 	enum TCriteria

   115 		{

   116 		ELessThan,

   117 		ELessThanOrEqualTo,

   118 		EGreaterThan,

   119 		EGreaterThanOrEqualTo

   120 		};

   121 public:

   122 	static CSortChecker* NewL(CTestConductor& aConductor);

   123 	~CSortChecker();

   124 	void AddContactL(const TDesC& aFirstName,const TDesC& aLastName);

   125 	void RemoveContactL(const TDesC& aFirstName,const TDesC& aLastName);

   126 	TPtrC ContactAt(TSortOrder aOrder,TInt aIndex) const;

   127 	TInt Count() const;

   128 	TInt Count(TSortOrder aOrder,const TDesC& aLowBoundary,const TDesC& aHighBoundary) const;

   129 	TInt CountLow(TSortOrder aOrder,const TDesC& aHighBoundary) const;

   130 	TInt CountHigh(TSortOrder aOrder,const TDesC& aLowBoundary) const;

   131 	void Sort();	

   132 	void CheckSort(TSortOrder aOrder,const TDesC& aName,TInt aIndex) const;

   133 	void CheckSortLowSubView(TSortOrder aOrder,const TDesC& aName,TInt aIndex,const TDesC& aHighBoundary) const;

   134 	void CheckSortHighSubView(TSortOrder aOrder,const TDesC& aName,TInt aIndex,const TDesC& aLowBoundary) const;

   135 	void CheckSortSubView(TSortOrder aOrder,const TDesC& aName,TInt aIndex,const TDesC& aLowBoundary,const TDesC& aHighBoundary) const;

   136 private:

   137 	CSortChecker(CTestConductor& aConductor);

   138 	void ConstructL();

   139 	TInt FindIndex(TSortOrder aOrder,const TDesC& aBoundary,TCriteria aCriteria) const;

   140 	static TInt Compare(const HBufC& aFirst, const HBufC& aSecond);

   141 	static TBool Match(const HBufC& aFirst,const HBufC& aSecond);

   142 private:

   143 	CTestConductor& iConductor;

   144 	TCollationMethod* iCollateMethod;

   145 	RPointerArray<HBufC> iSortedFirstLast;

   146 	RPointerArray<HBufC> iSortedLastFirst;

   147 	};

   148 

   149 

   150 //

   151 // CTestBase.

   152 //

   153 

   154 class CTestBase : public CBase

   155 	{

   156 public:

   157 	virtual void HandleNotificationL(const CContactViewBase& aView,const TContactViewEvent& aEvent)=0;

   158 protected:

   159 	CTestBase(CTestConductor& aConductor);

   160 protected:

   161 	CTestConductor& iConductor;

   162 	};

   163 

   164 

   165 //

   166 // CViewCreator.

   167 //

   168 

   169 class CViewCreator : public CTestBase

   170 	{

   171 public:

   172 	static CViewCreator* NewL(CTestConductor& aConductor);

   173 	CContactLocalView* CreateLocalViewL(const RContactViewSortOrder& aSortOrder);

   174 	CContactNamedLocalView* CreateNamedLocalViewL(const TDesC& aName,const RContactViewSortOrder& aSortOrder);

   175 	CContactRemoteView* CreateRemoteViewL(const RContactViewSortOrder& aSortOrder);

   176 	CContactNamedRemoteView* CreateNamedRemoteViewL(const TDesC& aName,const RContactViewSortOrder& aSortOrder);

   177 	CContactSubView* CreateSubViewL(CContactViewBase& aUnderlyingView,const TDesC& aBoundary);

   178 	CContactSubView* CreateSubViewL(CContactViewBase& aUnderlyingView,const TDesC& aLowBoundary,const TDesC& aHighBoundary);

   179 	CContactConcatenatedView* CreateConcatenatedViewL(RPointerArray<CContactViewBase>& aComponentViews);

   180 	virtual void HandleNotificationL(const CContactViewBase& aView,const TContactViewEvent& aEvent);

   181 private:

   182 	CViewCreator(CTestConductor& aConductor);

   183 	CContactViewBase* iView;

   184 	};

   185 

   186 

   187 //

   188 // CContactAdder.

   189 //

   190 

   191 class CContactAdder : public CTestBase

   192 	{

   193 public:

   194 	static CContactAdder* NewL(CTestConductor& aConductor);

   195 	~CContactAdder();

   196 	void AddContactsL(const TDesC& aFileName,TInt aNumViews);

   197 	virtual void HandleNotificationL(const CContactViewBase& aView,const TContactViewEvent& aEvent);

   198 	static TBool ReadNamePairL(RFile aFile,TDes& aFirstName,TDes& aLastName);

   199 private:

   200 	CContactAdder(CTestConductor& aConductor);

   201 	void ConstructL();

   202 	void AddOneContactL();

   203 private:

   204 	RFs iFs;

   205 	RFile iFile;

   206 	CContactTemplate* iTemplate;

   207 	TBool iFinished;

   208 	TInt iNumViews;

   209 	TInt iNumNotifications;

   210 	CRandomContactGenerator* iRandomGenerator;

   211 	};

   212 

   213 

   214 //

   215 // CContactRemover.

   216 //

   217 

   218 class CContactRemover : public CTestBase

   219 	{

   220 public:

   221 	static CContactRemover* NewL(CTestConductor& aConductor);

   222 	~CContactRemover();

   223 	void RemoveContactsL(const TDesC& aFileName,TInt aNumViews);

   224 	virtual void HandleNotificationL(const CContactViewBase& aView,const TContactViewEvent& aEvent);

   225 private:

   226 	CContactRemover(CTestConductor& aConductor);

   227 	void ConstructL();

   228 	void RemoveOneContactL();

   229 private:

   230 	RFs iFs;

   231 	RFile iFile;

   232 	TBool iFinished;

   233 	TInt iNumViews;

   234 	TInt iNumNotifications;

   235 	};

   236 

   237 

   238 //

   239 // CViewExerciser.

   240 //

   241 

   242 class CViewExerciser : public CTestBase

   243 	{

   244 public:

   245 	static CViewExerciser* NewL(CTestConductor& aConductor);

   246 	//void ProfileViewL(CContactViewBase& aView);

   247 	void ExerciseViewL(CSortChecker::TSortOrder aSortOrder,CContactViewBase& aView);

   248 	void ExerciseSubViewL(CSortChecker::TSortOrder aSortOrder,CContactViewBase& aView,const TDesC& aLowBoundary,const TDesC& aHighBoundary);

   249 	void ExerciseLowSubViewL(CSortChecker::TSortOrder aSortOrder,CContactViewBase& aView,const TDesC& aLowBoundary);

   250 	void ExerciseHighSubViewL(CSortChecker::TSortOrder aSortOrder,CContactViewBase& aView,const TDesC& aHighBoundary);

   251 	void QueueNextTestWhenComplete(TBool aQueue);

   252 	~CViewExerciser();

   253 	virtual void HandleNotificationL(const CContactViewBase& aView,const TContactViewEvent& aEvent);

   254 private:

   255 	CViewExerciser(CTestConductor& aConductor);

   256 	void ConstructL();

   257 private:

   258 	CContactTextDef* iTextDef_FirstLast;

   259 	CContactTextDef* iTextDef_LastFirst;

   260 	TBool iQueue;

   261 	};

   262 

   263 

   264 //

   265 // CSortOrderChanger.

   266 //

   267 

   268 class CSortOrderChanger : public CTestBase

   269 	{

   270 public:

   271 	static CSortOrderChanger* NewL(CTestConductor& aConductor);

   272 	void ChangeSortOrderL(RContactViewSortOrder& aSortOrder,CContactNamedLocalView& aView,TInt aNumViews);

   273 	void ChangeSortOrderL(RContactViewSortOrder& aSortOrder,CContactNamedRemoteView& aView,TInt aNumViews);

   274 	~CSortOrderChanger();

   275 	virtual void HandleNotificationL(const CContactViewBase& aView,const TContactViewEvent& aEvent);

   276 private:

   277 	CSortOrderChanger(CTestConductor& aConductor);

   278 private:

   279 	CContactTextDef* iTextDef;

   280 	TInt iNumViews;

   281 	TInt iNumNotifications;

   282 	};

   283 

   284 //

   285 //OOM TEST CODE

   286 //

   287 class COomTest;

   288 class COomFailBase : public CBase, public MContactViewObserver

   289 	{

   290 public:

   291 	~COomFailBase();

   292 	COomFailBase(COomTest *aOomTest,CContactDatabase* aDb,CContactViewBase* aUnderlyingView);

   293 	virtual void ConstructL();

   294 	virtual void PreFailL();

   295 	virtual void ClearUp();

   296 	virtual void FailL()=0;

   297 	virtual TOomTestName TestName()=0;

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

   299 	void ClearEventQueueL();

   300 private: // From MContactViewObserver.

   301 	virtual void HandleContactViewEvent(const CContactViewBase& aView,const TContactViewEvent& aEvent)=0;

   302 protected:

   303 	COomTest *iOomTest;

   304 	CContactDatabase* iDb;

   305 	CContactViewBase* iUnderlyingView;

   306 	};

   307 

   308 

   309 class COomTest : public CBase

   310 	{

   311 public:

   312 	COomTest(CContactDatabase* aDb,CContactLocalView* aLocalView,CContactRemoteView* aRemoteView,CContactGroup* aGroup,CTestConductor& aConductor);

   313 	void ConstructL();

   314 	~COomTest();

   315 	TBool DoTestL();

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

   317 	void Test(TBool aMustBeTrue);

   318 	TBool TestsL();

   319 	CTestConductor& Conductor() const;

   320 private:

   321 	CContactDatabase* iDb;

   322 	CContactLocalView* iLocalView;

   323 	CContactRemoteView* iRemoteView;

   324 	CContactGroup* iGroupOne;//not owned

   325 	CTestConductor& iConductor;

   326 	};

   327 

   328 

   329 class COomLocalView : public COomFailBase

   330 	{

   331 public:

   332 	inline COomLocalView(COomTest *aOomTest,CContactDatabase* aDb,CContactViewBase* aUnderlyingView, const TDesC8& aSortPluginName = KNullDesC8) :

   333 		 COomFailBase(aOomTest,aDb,aUnderlyingView),  iSortPluginName(aSortPluginName){};

   334 	void FailL();

   335 	void PreFailL();

   336 	void ClearUp();

   337 	inline TOomTestName TestName() {return(_L("CContactLocalView : NewL"));};

   338 private:

   339 	virtual void HandleContactViewEvent(const CContactViewBase& aView,const TContactViewEvent& aEvent);

   340 private:

   341 	RContactViewSortOrder iSortOrder;

   342 	CContactLocalView* iLocalView;

   343 	TPtrC8 iSortPluginName;

   344 	};

   345 

   346 //

   347 class COomRemoteView : public COomFailBase

   348 	{

   349 public:

   350 	inline COomRemoteView(COomTest *aOomTest,CContactDatabase* aDb,CContactViewBase* aUnderlyingView, const TDesC8& aSortPluginName = KNullDesC8) : 

   351 		COomFailBase(aOomTest,aDb,aUnderlyingView),  iSortPluginName(aSortPluginName){};

   352 	void FailL();

   353 	void PreFailL();

   354 	void ClearUp();

   355 	inline TOomTestName TestName() {return(_L("CContactRemoteView : NewL"));};

   356 private:

   357 	virtual void HandleContactViewEvent(const CContactViewBase& aView,const TContactViewEvent& aEvent);

   358 private:

   359 	RContactViewSortOrder iSortOrder;

   360 	CContactRemoteView* iRemoteView;

   361 	TPtrC8 iSortPluginName;

   362 	};

   363 

   364 //

   365 class COomSubView : public COomFailBase

   366 	{

   367 public:

   368 	inline COomSubView(COomTest *aOomTest,CContactDatabase* aDb,CContactViewBase* aUnderlyingView) : COomFailBase(aOomTest,aDb,aUnderlyingView) {};

   369 	void FailL();

   370 	void PreFailL();

   371 	void ClearUp();

   372 	inline TOomTestName TestName() {return(_L("CContactSubView : NewL"));};

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

   374 private:

   375 	virtual void HandleContactViewEvent(const CContactViewBase& aView,const TContactViewEvent& aEvent);

   376 private:

   377 	CContactSubView* iSubViewAbc;

   378 	};

   379 

   380 //

   381 class COomFilteredView : public COomFailBase

   382 	{

   383 public:

   384 	inline COomFilteredView(COomTest *aOomTest,CContactDatabase* aDb,CContactViewBase* aUnderlyingView) : COomFailBase(aOomTest,aDb,aUnderlyingView) {};

   385 	void FailL();

   386 	void PreFailL();

   387 	void ClearUp();

   388 	inline TOomTestName TestName() {return(_L("COomFilteredView : NewL"));};

   389 private:

   390 	virtual void HandleContactViewEvent(const CContactViewBase& aView,const TContactViewEvent& aEvent);

   391 private:

   392 	CContactFilteredView* iPhonableFilterView;

   393 	};

   394 

   395 

   396 //

   397 class COomGroupView : public COomFailBase

   398 	{

   399 public:

   400 	inline COomGroupView(COomTest *aOomTest,CContactDatabase* aDb,CContactViewBase* aUnderlyingView,CContactGroup* aGroup) : COomFailBase(aOomTest,aDb,aUnderlyingView),iGroupOne(aGroup) {};

   401 	void FailL();

   402 	void PreFailL();

   403 	void ClearUp();

   404 	inline TOomTestName TestName() {return(_L("COomGroupView"));};

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

   406 private:

   407 	virtual void HandleContactViewEvent(const CContactViewBase& aView,const TContactViewEvent& aEvent);

   408 private:

   409 	CContactGroupView* iGroupView;

   410 	TBool iAsStarted;

   411 	CContactGroup* iGroupOne;//not owned

   412 	};

   413 

   414 /** Tests construction of contacts matching criteria method in OOM situations */

   415 class COomMatchingCriteria: public COomFailBase

   416 	{

   417 public:

   418 	inline COomMatchingCriteria(COomTest *aOomTest,CContactDatabase* aDb,CContactViewBase* aUnderlyingView) : COomFailBase(aOomTest,aDb,aUnderlyingView) {};

   419 	inline TOomTestName TestName() {return(_L("ContactsMatchingCriteriaL"));};

   420 	void FailL();

   421 	static void CleanupContactArray(TAny* aArray);

   422 private:

   423 	virtual void HandleContactViewEvent(const CContactViewBase& aView,const TContactViewEvent& aEvent);

   424 	};

   425