--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/phonebookengines_old/contactsmodel/tsrc/t_database_killer.cpp	Tue Aug 31 15:05:21 2010 +0300
@@ -0,0 +1,470 @@
+// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <e32std.h>
+#include <e32test.h>
+#include <cntdb.h>
+#include <cntitem.h>
+#include <cntfldst.h>
+#include "t_utils2.h"
+#include "t_database_killer.h"
+
+
+// Test Macro
+LOCAL_D RTest test(_L("T_DATABASE_KILLER"));
+
+_LIT(KTestName,"@SYMTESTCaseID:PIM-T-DATABASE-KILLER-0001 t_database_killer");
+_LIT(KLogFileName,"t_database_killer.log");
+
+_LIT(KDbFileName,"c:t_database_killer.cdb");
+
+const TInt KNumSmsContacts=5;
+const TInt KNumWorkEmailContacts=4;
+const TInt KNumHomeEmailContacts=4;
+const TInt KNumLandlineContacts=10;
+const TInt KNumFaxContacts=4;
+
+CTestConductor* CTestConductor::NewL(TBool aKillFourTimes)
+	{
+	CTestConductor* self=new(ELeave) CTestConductor(aKillFourTimes);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	self->RunTestsL();
+	CleanupStack::Pop();
+	return self;
+	}
+
+CTestConductor::~CTestConductor()
+	{
+	delete iLog;
+	delete iDb;
+	delete iTempFiles;
+	iFs.Close();
+	}
+
+CTestConductor::CTestConductor(TBool aKillFourTimes)
+	{
+	iKillFourTimes = aKillFourTimes;
+	}
+
+void CTestConductor::ConstructL()
+	{
+	User::LeaveIfError(iFs.Connect());
+	iTempFiles=CTestRegister::NewLC();
+	CleanupStack::Pop(iTempFiles);
+	iTempFiles->RegisterL(KDbFileName, EFileTypeCnt);
+	iLog=CLog::NewL(test,KLogFileName);
+	iDb=CContactDatabase::ReplaceL(KDbFileName);
+	}
+
+
+void CTestConductor::RunTestsL()
+	{
+	CDatabaseTester* tester=CDatabaseTester::NewL(*iLog,*iDb,this, iKillFourTimes);
+	CleanupStack::PushL(tester);
+	CActiveScheduler::Start();
+	CleanupStack::Pop(tester);
+	// error from CDatabaseTester ?
+	User::LeaveIfError(iTestError);
+	}
+
+void CTestConductor::SetTestError(TInt aTestError)
+	{
+	iTestError = aTestError;
+	}
+
+//
+// CDatabaseTester.
+//
+
+CDatabaseTester* CDatabaseTester::NewL(CLog& aLog,CContactDatabase& aDb,CTestConductor* aTestConductor, TBool aKillFourTimes)
+	{
+	CDatabaseTester* self=new(ELeave) CDatabaseTester(aLog,aDb,aTestConductor, aKillFourTimes);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop();
+	return self;
+	}
+
+CDatabaseTester::~CDatabaseTester()
+	{
+	delete iRandomGenerator;
+
+	DeleteProcess();
+
+	}
+
+CDatabaseTester::CDatabaseTester(CLog& aLog,CContactDatabase& aDb,CTestConductor* aTestConductor, TBool aKillFourTimes)
+	: CActive(EPriorityStandard),iLog(aLog),iDb(aDb),iCurrentTest(EInitialisingTests),iTestConductor(aTestConductor)
+	{
+	CActiveScheduler::Add(this);
+	iTotalContacts = 0;
+	iKillFourTimes = aKillFourTimes;
+	}
+
+void CDatabaseTester::ConstructL()
+	{
+	iRandomGenerator=CRandomContactGenerator::NewL();
+	iRandomGenerator->SetDbL(iDb);
+	NextTest();
+	}
+
+void CDatabaseTester::RunL()
+	{
+	CContactIdArray* arrayOfContacts = NULL;
+	TInt num = 0;
+	TInt counter = 0;
+	TInt halfOfAllContacts = 0;
+	switch (iCurrentTest)
+		{
+		case EAddContacts:
+			iLog.LogLine(_L("=== Add Contacts to DB"));
+			AddContactsL();
+			NextTest();
+			break;
+
+		case EKillThreadFirstTime:
+			iLog.LogLine(_L("=== Kill Server 1st Time"));
+			arrayOfContacts = iDb.FindLC(_L(""), NULL);
+			num = arrayOfContacts->Count();
+			test(num == iTotalContacts);
+			FindServerAndKillItL(2000);
+			NextTest();
+			break;
+
+		case ERemoveContacts:
+			iLog.LogLine(_L("==== Remove Some Contacts"));
+			arrayOfContacts = iDb.FindLC(_L(""), NULL);
+			num = arrayOfContacts->Count();
+			test(num == iTotalContacts);
+
+			halfOfAllContacts = num / 2;
+			for ( counter = 0; counter < halfOfAllContacts; counter++)
+				{
+				iDb.DeleteContactL((*arrayOfContacts)[counter]);
+				iTotalContacts--;
+				}
+			CleanupStack::PopAndDestroy(arrayOfContacts);
+			arrayOfContacts = iDb.FindLC(_L(""), NULL);
+			num = arrayOfContacts->Count();
+			test(num == iTotalContacts);
+			NextTest();
+			break;
+
+		case EKillThreadSecondTime:
+			iLog.LogLine(_L("=== Kill Server 2nd Time"));
+			arrayOfContacts = iDb.FindLC(_L(""), NULL);
+			num = arrayOfContacts->Count();
+			test(num == iTotalContacts);
+			FindServerAndKillItL(2000);
+			NextTest();
+			break;
+
+		case EAddMoreContacts:
+			iLog.LogLine(_L("=== Add More Contacts to DB"));
+			AddContactsL();
+			NextTest();
+			break;
+
+		case EKillThreadThirdTime:
+			iLog.LogLine(_L("=== Kill Server 3rd Time"));
+			arrayOfContacts = iDb.FindLC(_L(""), NULL);
+			num = arrayOfContacts->Count();
+			test(num == iTotalContacts);
+			FindServerAndKillItL(2000);
+			NextTest();
+			break;
+
+		case ERemoveMoreContacts:
+			iLog.LogLine(_L("==== Remove Some More Contacts"));
+			arrayOfContacts = iDb.FindLC(_L(""), NULL);
+			num = arrayOfContacts->Count();
+			test(num == iTotalContacts);
+
+			halfOfAllContacts = num / 2;
+			for ( counter = 0; counter < halfOfAllContacts; counter++)
+				{
+				iDb.DeleteContactL((*arrayOfContacts)[counter]);
+				iTotalContacts--;
+				}
+			CleanupStack::PopAndDestroy(arrayOfContacts);
+			arrayOfContacts = iDb.FindLC(_L(""), NULL);
+			num = arrayOfContacts->Count();
+			test(num == iTotalContacts);
+			NextTest();
+			break;
+
+		case EKillThreadForthTime:
+			if (iKillFourTimes)
+				{
+				iLog.LogLine(_L("=== Kill Server 4th Time"));
+				arrayOfContacts = iDb.FindLC(_L(""), NULL);
+				num = arrayOfContacts->Count();
+				test(num == iTotalContacts);
+				FindServerAndKillItL(2000);
+				}
+			else
+				{
+				iLog.LogLine(_L("=== Skipping : Kill Server 4th Time"));
+				}
+			NextTest();
+			break;
+
+		case ENumTests:
+			iLog.LogLine(_L("==== Filter View Finished"));
+			arrayOfContacts = iDb.FindLC(_L(""), NULL);
+			num = arrayOfContacts->Count();
+			test(num == iTotalContacts);
+			CActiveScheduler::Stop();
+			delete this;
+			break;
+
+		default:
+			ASSERT(EFalse);
+			break;
+		}
+
+	if (arrayOfContacts != NULL)
+		{
+		CleanupStack::PopAndDestroy(arrayOfContacts);
+		}
+	}
+
+
+TInt CDatabaseTester::RunError(TInt aError)
+	{
+	// propagate error back to CTestConductor
+	iTestConductor->SetTestError(aError);
+
+	// some diagnostic info on where the test failed
+	switch (iCurrentTest)
+		{
+		case EAddContacts: test.Printf(_L("Failed at test step AddContacts (%i) error %i"), iCurrentTest, aError); break;
+		case EKillThreadFirstTime: test.Printf(_L("Failed at test step KillThreadFirstTime (%i) error %i"), iCurrentTest, aError); break;
+		case ERemoveContacts: test.Printf(_L("Failed at test step RemoveContacts (%i) error %i"), iCurrentTest, aError); break;
+		case EKillThreadSecondTime: test.Printf(_L("Failed at test step KillThreadSecondTime (%i) error %i"), iCurrentTest, aError); break;
+		case EAddMoreContacts: test.Printf(_L("Failed at test step AddMoreContacts (%i) error %i"), iCurrentTest, aError); break;
+		case EKillThreadThirdTime: test.Printf(_L("Failed at test step KillThreadThirdTime (%i) error %i"), iCurrentTest, aError); break;
+		case ERemoveMoreContacts: test.Printf(_L("Failed at test step RemoveMoreContacts (%i) error %i"), iCurrentTest, aError); break;
+		case EKillThreadForthTime: test.Printf(_L("Failed at test step KillThreadForthTime (%i) error %i"), iCurrentTest, aError); break;
+
+		case ENumTests: test.Printf(_L("Failed at test step NumTests (%i) error %i"), iCurrentTest, aError); break;
+
+		default: test.Printf(_L("Failed at test step %i error %i"), iCurrentTest, aError); break;
+		}
+
+	// stop test
+	CActiveScheduler::Stop();
+
+	return KErrNone;
+	}
+
+
+void CDatabaseTester::NextTest()
+	{
+	iCurrentTest = static_cast<TTest>( static_cast<TInt>(iCurrentTest) + 1 );
+	TRequestStatus *pS=&iStatus;
+	User::RequestComplete(pS,KErrNone);
+	SetActive();
+	}
+
+
+
+void CDatabaseTester::DoCancel()
+	{
+	}
+
+void CDatabaseTester::FindServerAndKillItL(TInt aDelay)
+	{
+	if (aDelay > 0) User::After(aDelay);
+	SetupProcessL();
+	OpenAndKillProcess();
+	WaitForServerToClose();
+	}
+
+void CDatabaseTester::AddContactsL()
+	{
+	test.Printf(_L("Adding "));
+	TInt ii;
+	for (ii=0;ii<KNumSmsContacts;ii++)
+		{
+		TInt bit=0;
+		bit |= CContactDatabase::ESmsable;
+		iRandomGenerator->AddTypicalContactForFilterL(bit);
+		iTotalContacts++;
+		}
+	for (ii=0;ii<KNumWorkEmailContacts;ii++)
+		{
+		TInt bit=0;
+		bit |= CContactDatabase::EMailable;
+		iRandomGenerator->AddTypicalContactForFilterL(bit);
+		iTotalContacts++;
+		}
+	for (ii=0;ii<KNumHomeEmailContacts;ii++)
+		{
+		TInt bit=0;
+		bit |= CContactDatabase::EMailable;
+		bit |= CContactDatabase::EHome;
+		iRandomGenerator->AddTypicalContactForFilterL(bit);
+		iTotalContacts++;
+		}
+	for (ii=0;ii<KNumLandlineContacts;ii++)
+		{
+		TInt bit=0;
+		bit |= CContactDatabase::ELandLine;
+		iRandomGenerator->AddTypicalContactForFilterL(bit);
+		iTotalContacts++;
+		}
+	for (ii=0;ii<KNumFaxContacts;ii++)
+		{
+		TInt bit=0;
+		bit |= CContactDatabase::EFaxable;
+		iRandomGenerator->AddTypicalContactForFilterL(bit);
+		iTotalContacts++;
+		}
+	}
+
+void CDatabaseTester::OpenAndKillProcess()
+	{
+	iLog.LogLine(_L("==== Open and Kill Process"));
+	/*TInt retVal = */iProcessOrThread.iProcess.iExecution->Open(iProcessOrThreadFullName);
+	iProcessOrThread.iProcess.iExecution->Kill(KErrNone);
+	}
+
+void CDatabaseTester::OpenAndKillThread()
+	{
+	iLog.LogLine(_L("==== Open and Kill Thread"));
+	iProcessOrThread.iThread.iExecution->Open(iProcessOrThreadFullName);
+	iProcessOrThread.iThread.iExecution->Kill(KErrNone);
+	}
+
+void CDatabaseTester::WaitForServerToClose()
+	{
+	const TInt KRetryPeriod(100000);
+	const TInt KMaxRetries(50);
+	
+	TInt attempts = 0;
+	do
+		{
+		// Attempt to find the server process
+		TRAPD(err, SetupProcessL());
+		if (err == KErrNotFound)
+			{
+			// Server not found - it has closed
+			return;
+			}
+		
+		
+		// Not found, wait then try again
+		User::After(KRetryPeriod);
+		
+		_LIT(KRetryReportFormat, "Close server attempt %d failed\n");
+		test.Printf(KRetryReportFormat, attempts + 1);
+		++attempts;
+		
+		} while (attempts < KMaxRetries);
+	
+	// Failed to close contacts server
+	_LIT(KServerCloseFailed, "Warning: Unable to verify contacts server has closed\n");
+	test.Printf(KServerCloseFailed);
+	}
+
+void CDatabaseTester::SetupThreadL()
+	{
+	DeleteThread();
+	iProcessOrThread.iThread.iFind = new (ELeave) TFindThread(_L("CntLockServer*"));
+	iProcessOrThread.iThread.iExecution = new (ELeave) RThread();
+	iProcessOrThread.iThread.iFind->Next(iProcessOrThreadFullName);
+	}
+
+void CDatabaseTester::SetupProcessL()
+	{
+	DeleteProcess();
+	iProcessOrThread.iProcess.iFind = new (ELeave) TFindProcess(_L("CNTSRV*"));
+	iProcessOrThread.iProcess.iExecution = new (ELeave) RProcess();
+	User::LeaveIfError(iProcessOrThread.iProcess.iFind->Next(iProcessOrThreadFullName));
+	}
+
+void CDatabaseTester::DeleteThread()
+	{
+	delete iProcessOrThread.iThread.iFind;
+	if (iProcessOrThread.iThread.iExecution != NULL) iProcessOrThread.iThread.iExecution->Close();
+	delete iProcessOrThread.iThread.iExecution;
+
+	iProcessOrThread.iThread.iFind = NULL;
+	iProcessOrThread.iThread.iExecution = NULL;
+	}
+
+void CDatabaseTester::DeleteProcess()
+	{
+	delete iProcessOrThread.iProcess.iFind;
+	if (iProcessOrThread.iProcess.iExecution != NULL) iProcessOrThread.iProcess.iExecution->Close();
+	delete iProcessOrThread.iProcess.iExecution;
+
+	iProcessOrThread.iProcess.iFind = NULL;
+	iProcessOrThread.iProcess.iExecution = NULL;
+	}
+
+void CDatabaseTester::AddContactL(TInt aBitwiseFilterType)
+	{
+	test.Printf(_L("Adding Contact"));
+	iRandomGenerator->AddTypicalContactForFilterL(aBitwiseFilterType);
+	iTotalContacts++;
+	}
+
+//
+// Main.
+//
+
+/**
+
+@SYMTestCaseID     PIM-T-DATABASE-KILLER-0001
+
+*/
+
+GLDEF_C TInt E32Main()
+	{
+	TInt error = KErrNone;
+	__UHEAP_MARK;
+	CActiveScheduler* scheduler=new CActiveScheduler;
+	if (scheduler)
+		{
+		CActiveScheduler::Install(scheduler);
+		CTrapCleanup* cleanup=CTrapCleanup::New();
+		if (cleanup)
+			{
+			CTestConductor* testConductor=NULL;
+			// NEWL parameters :
+			//  EFalse - kill the server 3 times
+			//  ETrue  - kill the server 4 times
+			//
+			// - The client should keep track of the number of times the server is restarted.
+			// - restarting the server more than 3 times should result in the client being paniced.
+			// - this has been tested, and the ability to test for this has been included for completeness.
+			test.Start(KTestName);
+
+			TRAP(error,testConductor=CTestConductor::NewL(EFalse));
+			RDebug::Print(_L("T_database_killer test completed \n"));
+			test(error == KErrNone);
+			test.End();
+			delete testConductor;
+			test.Close();
+			delete cleanup;
+			}
+		delete scheduler;
+		}
+	__UHEAP_MARKEND;
+	return KErrNone;
+    }