1 // Copyright (c) 2005-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 <bookmarkdatabase.h>

    17 #include "testutils.h"

    18 

    19 _LIT(KFilename, "tnotifytests.cpp");

    20 

    21 LOCAL_D CTestWrapper* gTestWrapper;

    22 LOCAL_D Bookmark::TAttachmentId gIconId;

    23 

    24 _LIT(KTxtTester1, 		"NotifyTEST Tester 1");

    25 _LIT(KTxtTester2, 		"NotifyTEST Tester 2");

    26 

    27 _LIT(KTxtFolder1, 		"NotifyTEST Folder 1");

    28 _LIT(KTxtFolder1_1, 	"NotifyTEST Folder 1.1");

    29 _LIT(KTxtFolder1_2, 	"NotifyTEST Folder 1.2");

    30 _LIT(KTxtFolder1_2_1, 	"NotifyTEST Folder 1.2.1");

    31 _LIT(KTxtFolder1_2_1_1,	"NotifyTEST Folder 1.2.1.1");

    32 

    33 _LIT(KTxtBookmark1,		"NotifyTEST Bookmark 1");

    34 _LIT(KTxtBookmark2,		"NotifyTEST Bookmark 2");

    35 _LIT(KTxtBookmark3, 	"NotifyTEST Bookmark 3");

    36 _LIT(KTxtBookmark4, 	"NotifyTEST Bookmark 4");

    37 _LIT(KTxtBookmark5, 	"NotifyTEST Bookmark 5");

    38 _LIT(KTxtBookmark6, 	"NotifyTEST Bookmark 6");

    39 _LIT(KTxtBookmark7, 	"NotifyTEST Bookmark 7");

    40 _LIT(KTxtBookmark8, 	"NotifyTEST Bookmark 8");

    41 _LIT(KTxtBookmark9, 	"NotifyTEST Bookmark 9");

    42 _LIT(KTxtBookmark10, 	"NotifyTEST Bookmark 10");

    43 

    44 _LIT8(KIconData,		"****4644372131**7*&879");

    45 const TUint32 KProxyId 	= 0x7CFFFFFF;

    46 

    47 /*

    48 TInt gIndentLevel = 0;

    49 TBufC<256> gBuffer;

    50 

    51 LOCAL_D const TDesC& Indented(const TDesC& aText)

    52 	{

    53 	TPtr ptr = gBuffer.Des();

    54 	ptr.SetLength(0);

    55 	TInt dots = gIndentLevel - 1;

    56 	for (;dots >= 0; --dots)

    57 		{

    58 		ptr.Append(_L(" . "));

    59 		}

    60 	ptr.Append(aText);

    61 	

    62 	return gBuffer;

    63 	}

    64 	

    65 LOCAL_D void DumpTreeL(RBkFolder& aFolder)

    66 	{

    67 	const TDesC& title = aFolder.Title();

    68 	gTestWrapper->Tester().Printf(Indented(title));

    69 

    70 	++gIndentLevel;

    71 	RBkNode item;

    72 	TInt count = aFolder.Count();

    73 	TInt index = 0;

    74 	for (;index < count; ++index)

    75 		{

    76 		item = aFolder.OpenItemL(index);

    77 		CleanupClosePushL(item);

    78 		if (item.Type() == Bookmark::ETypeFolder)

    79 			{

    80 			RBkFolder folder;

    81 			folder.OpenL(item);

    82 			CleanupClosePushL(folder);

    83 			DumpTreeL(folder);

    84 			CleanupStack::PopAndDestroy(&folder);

    85 			}

    86 		else

    87 			{

    88 			gTestWrapper->Tester().Printf(Indented(item.Title()));

    89 			}

    90 		CleanupStack::PopAndDestroy(&item);

    91 		}

    92 	--gIndentLevel;

    93 	}

    94 */

    95 class CNotifyTester: public CActive, public MBookmarkObserver

    96 	{

    97 public:

    98 	static CNotifyTester* NewL(const TDesC& aTitle);

    99 	~CNotifyTester();

   100 	

   101 	void CreateInitialTreeL();

   102 	void CheckInitialTreeL();

   103 	

   104 	void InitiateTest1L();

   105 	void InitiateTest2L();

   106 	void InitiateTest3L();

   107 	void StartTestL();

   108 	

   109 	void DeleteBookmarksL();

   110 	

   111 protected:

   112 	// From CActive

   113 	void RunL();

   114 	void DoCancel();

   115 	

   116 	// From MBookmarkObserver

   117 	void MBONotify(TEvent aEvent);

   118 	

   119 private:

   120 	CNotifyTester();

   121 	void ConstructL(const TDesC& aTitle);

   122 	

   123 private:

   124 	RBkDatabase iDatabase;

   125 	HBufC*		iTitle;

   126 	TInt		iCurrentTest;

   127 	};

   128 

   129 CNotifyTester* CNotifyTester::NewL(const TDesC& aTitle)

   130 	{

   131 	CNotifyTester* self = new (ELeave) CNotifyTester();

   132 	CleanupStack::PushL(self);

   133 	self->ConstructL(aTitle);

   134 	CleanupStack::Pop(self);

   135 	return self;

   136 	}

   137 

   138 CNotifyTester::CNotifyTester()

   139 	: CActive(EPriorityStandard), iCurrentTest(1)

   140 	{

   141 	}

   142 	

   143 CNotifyTester::~CNotifyTester()

   144 	{

   145 	delete iTitle;

   146 	Cancel();

   147 	iDatabase.Close();

   148 	}

   149 	

   150 void CNotifyTester::ConstructL(const TDesC& aTitle)

   151 	{

   152 	iTitle = aTitle.AllocL();

   153 	CActiveScheduler::Add(this);

   154 	iDatabase.OpenL(Bookmark::EVisibilityDefault, this);

   155 	}

   156 	

   157 void CNotifyTester::RunL()

   158 	{

   159 	iDatabase.RefreshL();

   160 	TInt err = KErrNone;

   161 	switch (iCurrentTest)

   162 		{

   163 	case 1:

   164 		gTestWrapper->Next(_L("Tree After Refresh"));

   165 		TRAP(err, iDatabase.GetIconL(gIconId));

   166 		gTestWrapper->TESTE(err == KErrNotFound, err);

   167 		gTestWrapper->TEST(iDatabase.DefaultProxy() == 0);

   168 		CheckInitialTreeL();

   169 		break;

   170 	case 2:

   171 		gTestWrapper->Next(_L("Check Icon"));

   172 		gTestWrapper->TEST(iDatabase.GetIconL(gIconId).Compare(KIconData) == 0);

   173 		gTestWrapper->TEST(iDatabase.DefaultProxy() == 0);

   174 		break;

   175 	case 3:

   176 		gTestWrapper->Next(_L("Check Config"));

   177 		gTestWrapper->TEST(iDatabase.DefaultProxy() == KProxyId);

   178 		break;

   179 	default:

   180 		// should not get here

   181 		User::Leave(KErrUnknown);

   182 		break;

   183 		}

   184 		

   185 	++iCurrentTest;

   186     CActiveScheduler::Stop();

   187 	}

   188 

   189 void CNotifyTester::DoCancel()

   190 	{

   191 	}

   192 	

   193 void CNotifyTester::MBONotify(TEvent aEvent)

   194 	{

   195 	if (IsActive())

   196 		{

   197 		if ((aEvent == EEventUpdatedBookmarkTree && iCurrentTest == 1) ||

   198 			(aEvent == EEventUpdatedIcons && iCurrentTest == 2 ) ||

   199 			(aEvent == EEventUpdatedConfig && iCurrentTest == 3 ) )

   200 			{

   201 			TRequestStatus* reqStatus = &iStatus;

   202 			User::RequestComplete(reqStatus, KErrNone);

   203 			}

   204 		}

   205 	}

   206 	

   207 void CNotifyTester::InitiateTest1L()

   208 	{

   209 	iDatabase.SetDefaultProxy(0);

   210 	CreateInitialTreeL();

   211 	CheckInitialTreeL();

   212 	iDatabase.CommitL();

   213 	}

   214 

   215 void CNotifyTester::InitiateTest2L()

   216 	{

   217 	gIconId = iDatabase.CreateIconL(KIconData);

   218 	iDatabase.CommitL();

   219 	}

   220 

   221 void CNotifyTester::InitiateTest3L()

   222 	{

   223 	iDatabase.SetDefaultProxy(KProxyId);

   224 	iDatabase.CommitL();

   225 	}

   226 

   227 void CNotifyTester::StartTestL()

   228 	{

   229 	if (IsActive())

   230 		{

   231 		return;

   232 		}

   233 	iStatus = KRequestPending;

   234 	SetActive();

   235 	}

   236 

   237 void CNotifyTester::DeleteBookmarksL()

   238 	{

   239 	RBkFolder root = iDatabase.OpenRootL();

   240 	CleanupClosePushL(root);

   241 	RBkNode item;

   242 	TInt index = root.Count() -1;

   243 	for (; index >= 0; --index)

   244 		{

   245 		item = root.OpenItemL(index);

   246 		CleanupClosePushL(item);

   247 		iDatabase.DeleteItemL(item.Id(), ETrue);

   248 		CleanupStack::PopAndDestroy(&item);

   249 		}

   250 	CleanupStack::PopAndDestroy(&root);

   251 	

   252 	User::LeaveIfError(iDatabase.DeleteIconL(gIconId));

   253 	iDatabase.SetDefaultProxy(0);

   254 	

   255 	iDatabase.CommitL();

   256 	

   257 	}

   258 

   259 /* 	

   260 After a call to the the tree structure looks like:

   261 			Root

   262 			 |

   263 [Bookmark1	Bookmark2	Folder1]

   264 						  |

   265 [Bookmark3	Bookmark4	Folder1_1	Folder1_2]

   266 						  |		  	 |

   267 					[Bookmark5]		[Bookmark6	Folder1_2_1]

   268 									  			  |

   269 								  			[Bookmark7	Folder1_2_1_1]

   270 								  						  |

   271 								  		[Bookmark8	Bookmark9	Bookmark10]

   272 

   273 */							  				 

   274 void CNotifyTester::CreateInitialTreeL()

   275 	{

   276 	// Create the first two bookmarks in the root

   277 	RBkBookmark bmrk = iDatabase.CreateBookmarkL();

   278 	CleanupClosePushL(bmrk);

   279 	bmrk.SetTitleL(KTxtBookmark1);

   280 	CleanupStack::PopAndDestroy(&bmrk);

   281 	

   282 	bmrk = iDatabase.CreateBookmarkL();

   283 	CleanupClosePushL(bmrk);

   284 	bmrk.SetTitleL(KTxtBookmark2);

   285 	CleanupStack::PopAndDestroy(&bmrk);

   286 	

   287 	// Create a folder and put 2 bookmarks into it

   288 	RBkFolder folder = iDatabase.CreateFolderL(KTxtFolder1);

   289 	CleanupClosePushL(folder);

   290 	bmrk = iDatabase.CreateBookmarkL(&folder);

   291 	CleanupClosePushL(bmrk);

   292 	bmrk.SetTitleL(KTxtBookmark3);

   293 	CleanupStack::PopAndDestroy(&bmrk);

   294 	bmrk = iDatabase.CreateBookmarkL(&folder);

   295 	CleanupClosePushL(bmrk);

   296 	bmrk.SetTitleL(KTxtBookmark4);

   297 	CleanupStack::PopAndDestroy(&bmrk);

   298 	

   299 	// Create two more folders in this folder and place a bookmark in each one

   300 	RBkFolder folderL2 = iDatabase.CreateFolderL(KTxtFolder1_1, &folder);

   301 	CleanupClosePushL(folderL2);

   302 	bmrk = iDatabase.CreateBookmarkL(&folderL2);

   303 	CleanupClosePushL(bmrk);

   304 	bmrk.SetTitleL(KTxtBookmark5);

   305 	CleanupStack::PopAndDestroy(&bmrk);

   306 	CleanupStack::PopAndDestroy(&folderL2);

   307 	

   308 	folderL2 = iDatabase.CreateFolderL(KTxtFolder1_2, &folder);

   309 	CleanupClosePushL(folderL2);

   310 	bmrk = iDatabase.CreateBookmarkL(&folderL2);

   311 	CleanupClosePushL(bmrk);

   312 	bmrk.SetTitleL(KTxtBookmark6);

   313 	CleanupStack::PopAndDestroy(&bmrk);

   314 	

   315 	// Create a folder under 1_2 and add a bookmark

   316 	RBkFolder folderL3 = iDatabase.CreateFolderL(KTxtFolder1_2_1, &folderL2);

   317 	CleanupClosePushL(folderL3);

   318 	bmrk = iDatabase.CreateBookmarkL(&folderL3);

   319 	CleanupClosePushL(bmrk);

   320 	bmrk.SetTitleL(KTxtBookmark7);

   321 	CleanupStack::PopAndDestroy(&bmrk);

   322 	

   323 	// Create a folder under 1_2_1 and add 3 bookmarks

   324 	RBkFolder folderL4 = iDatabase.CreateFolderL(KTxtFolder1_2_1_1, &folderL3);

   325 	CleanupClosePushL(folderL4);

   326 	bmrk = iDatabase.CreateBookmarkL(&folderL4);

   327 	CleanupClosePushL(bmrk);

   328 	bmrk.SetTitleL(KTxtBookmark8);

   329 	CleanupStack::PopAndDestroy(&bmrk);

   330 	bmrk = iDatabase.CreateBookmarkL(&folderL4);

   331 	CleanupClosePushL(bmrk);

   332 	bmrk.SetTitleL(KTxtBookmark9);

   333 	CleanupStack::PopAndDestroy(&bmrk);

   334 	bmrk = iDatabase.CreateBookmarkL(&folderL4);

   335 	CleanupClosePushL(bmrk);

   336 	bmrk.SetTitleL(KTxtBookmark10);

   337 	CleanupStack::PopAndDestroy(&bmrk);

   338 	

   339 	

   340 	CleanupStack::PopAndDestroy(&folderL4);

   341 	CleanupStack::PopAndDestroy(&folderL3);

   342 	CleanupStack::PopAndDestroy(&folderL2);

   343 	CleanupStack::PopAndDestroy(&folder);

   344 	}

   345 

   346 void CNotifyTester::CheckInitialTreeL()

   347 	{

   348 	RBkFolder root = iDatabase.OpenRootL();

   349 	CleanupClosePushL(root);

   350 	gTestWrapper->TEST(root.Count() == 3);

   351 	

   352 	if (root.Count() != 3)

   353 		{

   354 		User::Leave(KErrNotFound);

   355 		}

   356 		

   357 	RBkNode item = root.OpenItemL(0);

   358 	CleanupClosePushL(item);

   359 	gTestWrapper->TEST(item.Title().Compare(KTxtBookmark1) == 0);

   360 	CleanupStack::PopAndDestroy(&item);

   361 	

   362 	item = root.OpenItemL(2);

   363 	CleanupClosePushL(item);

   364 	gTestWrapper->TEST(item.Type() == Bookmark::ETypeFolder);

   365 	RBkFolder folder1;

   366 	folder1 = item.OpenFolderL();

   367 	CleanupStack::PopAndDestroy(&item);

   368 	CleanupClosePushL(folder1);

   369 	

   370 	item = folder1.OpenItemL(0);

   371 	CleanupClosePushL(item);

   372 	gTestWrapper->TEST(item.Title().Compare(KTxtBookmark3) == 0);

   373 	CleanupStack::PopAndDestroy(&item);

   374 	

   375 	item = folder1.OpenItemL(2);

   376 	CleanupClosePushL(item);

   377 	gTestWrapper->TEST(item.Type() == Bookmark::ETypeFolder);

   378 	RBkFolder folder1_1;

   379 	folder1_1 = item.OpenFolderL();

   380 	CleanupStack::PopAndDestroy(&item);

   381 	CleanupClosePushL(folder1_1);

   382 	

   383 	item = folder1_1.OpenItemL(0);

   384 	CleanupClosePushL(item);

   385 	gTestWrapper->TEST(item.Title().Compare(KTxtBookmark5) == 0);

   386 	CleanupStack::PopAndDestroy(&item);

   387 	

   388 	CleanupStack::PopAndDestroy(&folder1_1);

   389 	

   390 	item = folder1.OpenItemL(3);

   391 	CleanupClosePushL(item);

   392 	gTestWrapper->TEST(item.Type() == Bookmark::ETypeFolder);

   393 	RBkFolder folder1_2;

   394 	folder1_2 = item.OpenFolderL();

   395 	CleanupStack::PopAndDestroy(&item);

   396 	CleanupClosePushL(folder1_2);

   397 

   398 	item = folder1_2.OpenItemL(0);

   399 	CleanupClosePushL(item);

   400 	gTestWrapper->TEST(item.Title().Compare(KTxtBookmark6) == 0);

   401 	CleanupStack::PopAndDestroy(&item);

   402 	

   403 	item = folder1_2.OpenItemL(1);

   404 	CleanupClosePushL(item);

   405 	gTestWrapper->TEST(item.Type() == Bookmark::ETypeFolder);

   406 	RBkFolder folder1_2_1;

   407 	folder1_2_1 = item.OpenFolderL();

   408 	CleanupStack::PopAndDestroy(&item);

   409 	CleanupClosePushL(folder1_2_1);

   410 	

   411 	item = folder1_2_1.OpenItemL(0);

   412 	CleanupClosePushL(item);

   413 	gTestWrapper->TEST(item.Title().Compare(KTxtBookmark7) == 0);

   414 	CleanupStack::PopAndDestroy(&item);

   415 	

   416 	item = folder1_2_1.OpenItemL(1);

   417 	CleanupClosePushL(item);

   418 	gTestWrapper->TEST(item.Type() == Bookmark::ETypeFolder);

   419 	RBkFolder folder1_2_1_1;

   420 	folder1_2_1_1 = item.OpenFolderL();

   421 	CleanupStack::PopAndDestroy(&item);

   422 	CleanupClosePushL(folder1_2_1_1);

   423 	

   424 	item = folder1_2_1_1.OpenItemL(2);

   425 	CleanupClosePushL(item);

   426 	gTestWrapper->TEST(item.Title().Compare(KTxtBookmark10) == 0);

   427 	CleanupStack::PopAndDestroy(&item);

   428 	

   429 	CleanupStack::PopAndDestroy(&folder1_2_1_1);

   430 	CleanupStack::PopAndDestroy(&folder1_2_1);

   431 	CleanupStack::PopAndDestroy(&folder1_2);

   432 	CleanupStack::PopAndDestroy(&folder1);

   433 	CleanupStack::PopAndDestroy(&root);

   434 	}

   435 

   436 void DoNotifyTestsL(CTestWrapper* aTest)

   437 	{

   438 	gTestWrapper = aTest;

   439 	gTestWrapper->SetFile(KFilename);

   440 	gTestWrapper->Next(_L("*** Notify tests ***"));

   441 	

   442     // Create and install the active scheduler

   443     CActiveScheduler* scheduler=new (ELeave) CActiveScheduler;

   444     CleanupStack::PushL(scheduler);

   445     CActiveScheduler::Install(scheduler);

   446 

   447 	CNotifyTester* tester1 = CNotifyTester::NewL(KTxtTester1);

   448 	gTestWrapper->TEST(tester1 != NULL);

   449 	CleanupStack::PushL(tester1);

   450 	

   451 	CNotifyTester* tester2 = CNotifyTester::NewL(KTxtTester2);

   452 	gTestWrapper->TEST(tester2 != NULL);

   453 	CleanupStack::PushL(tester2);

   454 	

   455 	tester1->InitiateTest1L();

   456 	tester2->StartTestL();

   457 

   458     // start the active scheduler

   459     CActiveScheduler::Start();

   460 

   461 	tester1->InitiateTest2L();

   462 	tester2->StartTestL();

   463 

   464     // start the active scheduler

   465     CActiveScheduler::Start();

   466 

   467 	tester1->InitiateTest3L();

   468 	tester2->StartTestL();

   469 

   470     // start the active scheduler

   471     CActiveScheduler::Start();

   472 

   473 	tester1->DeleteBookmarksL();

   474 	

   475 	CleanupStack::PopAndDestroy(tester2);

   476 	CleanupStack::PopAndDestroy(tester1);

   477 	CleanupStack::PopAndDestroy(scheduler);

   478 	}