diff -r 000000000000 -r e686773b3f54 pimprotocols/phonebooksync/Test/TE_cntsync/te_cntsyncstress.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pimprotocols/phonebooksync/Test/TE_cntsync/te_cntsyncstress.cpp Tue Feb 02 10:12:17 2010 +0200 @@ -0,0 +1,1242 @@ +// 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 +#include + +#include "te_cntsyncbase.h" +#include "te_cntsyncstress.h" + +#ifdef SYMBIAN_CNTMODEL_V2 +_LIT(KContactsDBFile, "C:\\Private\\10003A73\\CONTACTS.CDB"); +_LIT(KContactsDBFileBackup, "C:\\Private\\10003A73\\CONTACTS.BAK"); +_LIT(KContactsSqliteDBFile, "C:\\Private\\10003A73\\SQLite__CONTACTS.CDB"); +_LIT(KContactsSqliteDBFileBackup, "C:\\Private\\10003A73\\SQLite__CONTACTS.BAK"); +#else +_LIT(KContactsDBFile, "C:\\Private\\100012A5\\DBS_100065FF_CONTACTS.CDB"); +_LIT(KContactsDBFileBackup, "C:\\Private\\100012A5\\DBS_100065FF_CONTACTS.BAK"); +#endif // SYMBIAN_CNTMODEL_V2 +_LIT(KContactsModelIniFile, "C:\\Private\\10003A73\\CntModel.ini"); +_LIT(KPhbkSyncIniFile,"C:\\Private\\102030A1\\Phbksync.ini"); +_LIT(KPhbkSyncIniFileBackup, "C:\\Private\\102030A1\\Phbksync.bak"); + + +/** + * Factory construction method. + * @return Pointer to CPhbkRequestDoSyncSimultaneouslyTest object + */ +CPhbkRequestDoSyncSimultaneouslyTest* CPhbkRequestDoSyncSimultaneouslyTest::NewL() + { + CPhbkRequestDoSyncSimultaneouslyTest* self = new(ELeave) CPhbkRequestDoSyncSimultaneouslyTest(); + return self; + } + +/** + * Default constructor. Each test step initialises it's own name. + */ +CPhbkRequestDoSyncSimultaneouslyTest::CPhbkRequestDoSyncSimultaneouslyTest() + { + SetTestStepName(_L("RequestDoSyncSimultaneouslyTest")); + } + +/** + * Request two simultaneous synchronisations. + * Two threads try to do a Synchronisation at once. + */ +enum TVerdict CPhbkRequestDoSyncSimultaneouslyTest::doTestStepL() + { + const TInt KStackSize=0x8000; + const TInt KHeapSize=0x8000; + const TInt KMaxHeapSize=0x80000; + + _LIT(KThreadName1,"Thread1"); + _LIT(KThreadName2,"Thread2"); + + RThread t1; + RThread t2; + + // Create the thread + User::LeaveIfError(t1.Create(KThreadName1,DoSyncThread,KStackSize,KHeapSize,KMaxHeapSize,NULL)); + User::LeaveIfError(t2.Create(KThreadName2,DoSyncThread,KStackSize,KHeapSize,KMaxHeapSize,NULL)); + + TRequestStatus reqStatus1; + TRequestStatus reqStatus2; + TBool req1Complete(EFalse); + TBool req2Complete(EFalse); + + t1.Logon(reqStatus1); // Notify when the thread dies + t2.Logon(reqStatus2); + t1.Resume(); // Start the threads + t2.Resume(); + User::WaitForRequest(reqStatus1); // Avoid using User::WaitForAnyRequest() + User::WaitForRequest(reqStatus2); + + while(req1Complete==EFalse || req2Complete==EFalse) + { + if (reqStatus1 != KRequestPending && req1Complete==EFalse) // Thread1 request completed + { + TESTCHECK(reqStatus1.Int(), KErrNone); + req1Complete=ETrue; + } + + if (reqStatus2 != KRequestPending && req2Complete==EFalse) // Thread2 request rejected + { + TESTCHECK(reqStatus2.Int(), KErrNone); + req2Complete=ETrue; + } + } + + t1.Close(); + t2.Close(); + + return TestStepResult(); + } + +/** + * Control passes to this function when the thread is first resumed, + * i.e. when the thread is initially scheduled to run. + */ +TInt CPhbkIntegrationStressTestBase::DoSyncThread(TAny* /*aPtr*/) + { + CActiveScheduler* scheduler = new CActiveScheduler; + if(!scheduler) + return KErrNoMemory; + CActiveScheduler::Install(scheduler); + CTrapCleanup* cleanup=CTrapCleanup::New(); + TRAP_IGNORE(DoSyncThreadL()); + delete cleanup; + delete CActiveScheduler::Current(); + return KErrNone; + } + +/** + * + */ +void CPhbkIntegrationStressTestBase::DoSyncThreadL() + { + RPhoneBookSession session; + User::LeaveIfError(session.Connect()); // Connect to the Phonebook Server + TRequestStatus status; + + // Attempt synchronisation for each phonebook + // Global ADN + session.DoSynchronisation(status); + User::WaitForRequest(status); + __ASSERT_ALWAYS((status.Int()==KErrNone) || (status.Int()==KErrInUse), User::Invariant()); + + + // Global SDN + session.DoSynchronisation(status, KUidIccGlobalSdnPhonebook); + User::WaitForRequest(status); + __ASSERT_ALWAYS((status.Int()==KErrNone) || (status.Int()==KErrInUse), User::Invariant()); + + // Global LND + session.DoSynchronisation(status, KUidIccGlobalLndPhonebook); + User::WaitForRequest(status); + __ASSERT_ALWAYS((status.Int()==KErrNone) || (status.Int()==KErrInUse), User::Invariant()); + + // USIM App + session.DoSynchronisation(status, KUidUsimAppAdnPhonebook); + User::WaitForRequest(status); + __ASSERT_ALWAYS((status.Int()==KErrNone) || (status.Int()==KErrInUse), User::Invariant()); + + + // Global FDN + session.DoSynchronisation(status, KUidIccGlobalFdnPhonebook); + User::WaitForRequest(status); + __ASSERT_ALWAYS((status.Int()==KErrNone) || (status.Int()==KErrInUse), User::Invariant()); + } + +/** + * Factory construction method. + * @return Pointer to CPhbkLaunchServerSimultaneouslyTest object + */ +CPhbkLaunchServerSimultaneouslyTest* CPhbkLaunchServerSimultaneouslyTest::NewL() + { + CPhbkLaunchServerSimultaneouslyTest* self = new(ELeave) CPhbkLaunchServerSimultaneouslyTest(); + return self; + } + +/** + * Default constructor. Each test step initialises it's own name. + */ +CPhbkLaunchServerSimultaneouslyTest::CPhbkLaunchServerSimultaneouslyTest() + { + SetTestStepName(_L("LaunchServerSimultaneouslyTest")); + } + +/** + * Create two threads which simultaneously attempt to connect to the Phonebook Server. + */ +enum TVerdict CPhbkLaunchServerSimultaneouslyTest::doTestStepL() + { + SetSimTsyTestNumberL(9); + + RThread thread1; + RThread thread2; + // Create the threads + User::LeaveIfError(thread1.Create(_L("Thread1"), ServerLaunchThread, KDefaultStackSize, 0x2000, 0x20000, NULL)); + User::LeaveIfError(thread2.Create(_L("Thread2"), ServerLaunchThread, KDefaultStackSize, 0x2000, 0x20000, NULL)); + thread1.Resume(); // Start the threads + thread2.Resume(); + User::After(5000000); + thread1.Close(); + thread2.Close(); + + return TestStepResult(); + } + + +/** + * Phonebook Server Launch thread function. + */ +TInt CPhbkIntegrationStressTestBase::ServerLaunchThread(TAny* /*aAny*/) + { + CActiveScheduler* scheduler = new CActiveScheduler; + if(!scheduler) + return KErrNoMemory; + + CActiveScheduler::Install(scheduler); + CTrapCleanup* cleanup=CTrapCleanup::New(); + CContactDatabase* db =NULL; + TRAPD(err, db = CContactDatabase::OpenL()); + __ASSERT_DEBUG(err==KErrNone,User::Invariant()); + TRAP(err, CheckServerThreadCountL(1)); + __ASSERT_DEBUG(err==KErrNone,User::Invariant()); + delete db; + delete cleanup; + delete CActiveScheduler::Current(); + return KErrNone; + } + +/** + * Checks the server thread count. + */ +void CPhbkIntegrationStressTestBase::CheckServerThreadCountL(TInt aExpectedCount) + { + TFullName name; + TInt count=0; + _LIT(KThreadToFind,"*PhBkSyncServer*"); // PHBKSYNC_SVR_NAME + TFindThread find(KThreadToFind); + + RThread candidate; + while(find.Next(name)==KErrNone) + { + // If the thread still lives, increase count. + if(candidate.Open(name)==KErrNone) + { + const TExitCategoryName& category = candidate.ExitCategory(); + + RDebug::Print(_L("[%x] CheckServerThreadCount thread: %x -----"), (TUint)RThread().Id(), (TUint)candidate.Id()); + RDebug::Print(_L("[%x] Thread %x ExitCategory %S"), (TUint)RThread().Id(), (TUint)candidate.Id(), &category); + RDebug::Print(_L("[%x] Thread %x ExitReason %d"), (TUint)RThread().Id(), (TUint)candidate.Id(), candidate.ExitReason()); + RDebug::Print(_L("[%x] Thread %x ExitType %d"), (TUint)RThread().Id(), (TUint)candidate.Id(), candidate.ExitType()); + + // If the thread has an ExitCategory, it is dead and not worthy of counting + if(category.Length()==0) + { + count++; + } + + candidate.Close(); + } + } + + __ASSERT_ALWAYS(count==aExpectedCount, User::Invariant()); + } + + +/** + * Factory construction method. + * @return Pointer to CPhbkRequestReadSimultaneouslyTest object + */ +CPhbkRequestReadSimultaneouslyTest* CPhbkRequestReadSimultaneouslyTest::NewL() + { + CPhbkRequestReadSimultaneouslyTest* self = new(ELeave) CPhbkRequestReadSimultaneouslyTest(); + return self; + } + +/** + * Default constructor. Each test step initialises it's own name. + */ +CPhbkRequestReadSimultaneouslyTest::CPhbkRequestReadSimultaneouslyTest() + { + SetTestStepName(_L("RequestReadSimultaneouslyTest")); + } + +/** + * Create three threads which simultaneously attempt to request Read from + * the Phonebook Server. + */ +enum TVerdict CPhbkRequestReadSimultaneouslyTest::doTestStepL() + { + RThread thread1; + RThread thread2; + RThread thread3; + // Create the threads + User::LeaveIfError(thread1.Create(_L("ThreadA"), MultipleReadThread, KDefaultStackSize, 0x2000, 0x20000, NULL)); + User::LeaveIfError(thread2.Create(_L("ThreadB"), MultipleReadThread, KDefaultStackSize, 0x2000, 0x20000, NULL)); + User::LeaveIfError(thread3.Create(_L("ThreadC"), MultipleReadThread, KDefaultStackSize, 0x2000, 0x20000, NULL)); + + TRequestStatus reqStatus1; + TRequestStatus reqStatus2; + TRequestStatus reqStatus3; + + thread1.Logon(reqStatus1); // Notify when the thread dies + thread2.Logon(reqStatus2); + thread3.Logon(reqStatus3); + thread1.Resume(); // Start the thread + thread2.Resume(); + thread3.Resume(); + User::WaitForRequest(reqStatus1); // Avoid using User::WaitForAnyRequest() + User::WaitForRequest(reqStatus2); + User::WaitForRequest(reqStatus3); + + TBool req1Complete(EFalse); + TBool req2Complete(EFalse); + TBool req3Complete(EFalse); + + while(req1Complete==EFalse || req2Complete==EFalse || req3Complete==EFalse) + { + if (reqStatus1 != KRequestPending && req1Complete==EFalse) // Thread1 request completed + { + TESTCHECK(reqStatus1.Int(), KErrNone); + req1Complete=ETrue; + } + + if (reqStatus2 != KRequestPending && req2Complete==EFalse) // Thread2 request rejected + { + TESTCHECK(reqStatus2.Int(), KErrNone); + req2Complete=ETrue; + } + + if (reqStatus3 != KRequestPending && req3Complete==EFalse) // Thread3 request rejected + { + TESTCHECK(reqStatus3.Int(), KErrNone); + req3Complete=ETrue; + } + } + +// User::After(5000000); + thread1.Close(); + thread2.Close(); + thread3.Close(); + + return TestStepResult(); + } + +/** + * Send Read request to the Phonebook server. + */ +TInt CPhbkIntegrationStressTestBase::MultipleReadThread(TAny* /*aAny*/) + { + CActiveScheduler* scheduler = new CActiveScheduler; + if(!scheduler) + return KErrNoMemory; + CActiveScheduler::Install(scheduler); + CTrapCleanup* cleanup=CTrapCleanup::New(); + TRAP_IGNORE(MultipleReadThreadL()); + delete cleanup; + delete CActiveScheduler::Current(); + return KErrNone; + } + +/** + * + */ +void CPhbkIntegrationStressTestBase::MultipleReadThreadL() + { + CPhbkIntegrationTestUtility* access = CPhbkIntegrationTestUtility::NewL(); + CleanupStack::PushL(access); + access->ReadContactL(KUidIccGlobalAdnPhonebook, KTest9ICCSlotsADN); + access->ReadContactL(KUidIccGlobalSdnPhonebook, KTest9ICCSlotsSDN); + access->ReadContactL(KUidIccGlobalLndPhonebook, KTest9ICCSlotsLND); + access->ReadContactL(KUidUsimAppAdnPhonebook, KTest9ICCSlotsUsim); + + CleanupStack::PopAndDestroy(access); + } + + +/** + * Factory construction method. + * @return Pointer to CPhbkRequestWriteSimultaneouslyTest object + */ +CPhbkRequestWriteSimultaneouslyTest* CPhbkRequestWriteSimultaneouslyTest::NewL() + { + CPhbkRequestWriteSimultaneouslyTest* self = new(ELeave) CPhbkRequestWriteSimultaneouslyTest(); + return self; + } + +/** + * Default constructor. Each test step initialises it's own name. + */ +CPhbkRequestWriteSimultaneouslyTest::CPhbkRequestWriteSimultaneouslyTest() + { + SetTestStepName(_L("RequestWriteSimultaneouslyTest")); + } + +/** + * Create three threads which simultaneously attempt to request Write from + * the Phonebook Server. + */ +enum TVerdict CPhbkRequestWriteSimultaneouslyTest::doTestStepL() + { + SetSimTsyTestNumberL(1); + DoSyncL(); + + RThread thread1; + RThread thread2; + RThread thread3; + // Create the threads + User::LeaveIfError(thread1.Create(_L("ThreadX"), MultipleWriteThread, KDefaultStackSize, 0x2000, 0x20000, NULL)); + User::LeaveIfError(thread2.Create(_L("ThreadY"), MultipleWriteThread, KDefaultStackSize, 0x2000, 0x20000, NULL)); + User::LeaveIfError(thread3.Create(_L("ThreadZ"), MultipleWriteThread, KDefaultStackSize, 0x2000, 0x20000, NULL)); + + TRequestStatus reqStatus1; + TRequestStatus reqStatus2; + TRequestStatus reqStatus3; + + thread1.Logon(reqStatus1); // Notify when the thread dies + thread2.Logon(reqStatus2); + thread3.Logon(reqStatus3); + thread1.Resume(); // Start the threads + thread2.Resume(); + thread3.Resume(); + User::WaitForRequest(reqStatus1); // Avoid using User::WaitForAnyRequest() + User::WaitForRequest(reqStatus2); + User::WaitForRequest(reqStatus3); + + TBool req1Complete(EFalse); + TBool req2Complete(EFalse); + TBool req3Complete(EFalse); + + while(req1Complete==EFalse || req2Complete==EFalse || req3Complete==EFalse) + { + if (reqStatus1 != KRequestPending && req1Complete==EFalse) // Thread1 request completed + { + TESTCHECK(reqStatus1.Int(), KErrNone); + req1Complete=ETrue; + } + + if (reqStatus2 != KRequestPending && req2Complete==EFalse) // Thread2 request rejected + { + TESTCHECK(reqStatus2.Int(), KErrNone); + req2Complete=ETrue; + } + + if (reqStatus3 != KRequestPending && req3Complete==EFalse) // Thread3 request rejected + { + TESTCHECK(reqStatus3.Int(), KErrNone); + req3Complete=ETrue; + } + + } + + thread1.Close(); + thread2.Close(); + thread3.Close(); + + return TestStepResult(); + } + + +/** + * Send Write request to the Phonebook server. + */ +TInt CPhbkIntegrationStressTestBase::MultipleWriteThread(TAny* /*aAny*/) + { + CActiveScheduler* scheduler = new CActiveScheduler; + if(!scheduler) + return KErrNoMemory; + CActiveScheduler::Install(scheduler); + CTrapCleanup* cleanup=CTrapCleanup::New(); + TRAP_IGNORE(MultipleWriteThreadL()); + delete cleanup; + delete CActiveScheduler::Current(); + return KErrNone; + } + +/** + * + */ +void CPhbkIntegrationStressTestBase::MultipleWriteThreadL() + { + CPhbkIntegrationTestUtility* access = CPhbkIntegrationTestUtility::NewL(); + CleanupStack::PushL(access); + access->AddContactL(KTestName, KTestNumber, KUidIccGlobalAdnPhonebook); + access->AddContactL(KTestName, KTestNumber, KUidIccGlobalSdnPhonebook); + access->AddContactL(KTestName, KTestNumber, KUidIccGlobalLndPhonebook); + access->AddContactL(KTestName, KTestNumber, KUidUsimAppAdnPhonebook, KTestEMail); + access->AddContactL(KTestName, KTestNumber, KUidIccGlobalFdnPhonebook); + + CleanupStack::PopAndDestroy(access); + } + +/** + * Factory construction method. + * @return Pointer to CPhbkRequestDeleteSimultaneouslyTest object + */ +CPhbkRequestDeleteSimultaneouslyTest* CPhbkRequestDeleteSimultaneouslyTest::NewL() + { + CPhbkRequestDeleteSimultaneouslyTest* self = new(ELeave) CPhbkRequestDeleteSimultaneouslyTest(); + return self; + } + +/** + * Default constructor. Each test step initialises it's own name. + */ +CPhbkRequestDeleteSimultaneouslyTest::CPhbkRequestDeleteSimultaneouslyTest() + { + SetTestStepName(_L("RequestDeleteSimultaneouslyTest")); + } + +/** + * Create three threads which simultaneously attempt to request Delete from + * the Phonebook Server. + */ +enum TVerdict CPhbkRequestDeleteSimultaneouslyTest::doTestStepL() + { + RThread thread1; + RThread thread2; + RThread thread3; + // Create the threads + User::LeaveIfError(thread1.Create(_L("Thread10"), MultipleDeleteThread, KDefaultStackSize, 0x2000, 0x20000, NULL)); + User::LeaveIfError(thread2.Create(_L("Thread11"), MultipleDeleteThread, KDefaultStackSize, 0x2000, 0x20000, NULL)); + User::LeaveIfError(thread3.Create(_L("Thread12"), MultipleDeleteThread, KDefaultStackSize, 0x2000, 0x20000, NULL)); + + TRequestStatus reqStatus1; + TRequestStatus reqStatus2; + TRequestStatus reqStatus3; + + thread1.Logon(reqStatus1); // Notify when the thread dies + thread2.Logon(reqStatus2); + thread3.Logon(reqStatus3); + thread1.Resume(); // Start the thread + thread2.Resume(); + thread3.Resume(); + User::WaitForRequest(reqStatus1); // Avoid using User::WaitForAnyRequest() + User::WaitForRequest(reqStatus2); + User::WaitForRequest(reqStatus3); + + TBool req1Complete(EFalse); + TBool req2Complete(EFalse); + TBool req3Complete(EFalse); + + while(req1Complete==EFalse || req2Complete==EFalse || req3Complete==EFalse) + { + if (reqStatus1 != KRequestPending && req1Complete==EFalse) // Thread1 request completed + { + TESTCHECK(reqStatus1.Int(), KErrNone); + req1Complete=ETrue; + } + + if (reqStatus2 != KRequestPending && req2Complete==EFalse) // Thread2 request rejected + { + TESTCHECK(reqStatus2.Int(), KErrNone); + req2Complete=ETrue; + } + + if (reqStatus3 != KRequestPending && req3Complete==EFalse) // Thread3 request rejected + { + TESTCHECK(reqStatus3.Int(), KErrNone); + req3Complete=ETrue; + } + } + + //User::After(5000000); + thread1.Close(); + thread2.Close(); + thread3.Close(); + + return TestStepResult(); + } + +/** + * Send Delete request to the Phonebook server. + */ +TInt CPhbkIntegrationStressTestBase::MultipleDeleteThread(TAny* /*aAny*/) + { + CActiveScheduler* scheduler = new CActiveScheduler; + if(!scheduler) + return KErrNoMemory; + CActiveScheduler::Install(scheduler); + CTrapCleanup* cleanup=CTrapCleanup::New(); + TRAP_IGNORE(MultipleDeleteThreadL()); + delete cleanup; + delete CActiveScheduler::Current(); + return KErrNone; + } + +/** + * Multiple delete thread + */ +void CPhbkIntegrationStressTestBase::MultipleDeleteThreadL() + { + CPhbkIntegrationTestUtility* access = CPhbkIntegrationTestUtility::NewL(); + CleanupStack::PushL(access); + access->DeleteContactL(KUidIccGlobalAdnPhonebook, 2); + access->DeleteContactL(KUidIccGlobalSdnPhonebook, 2); + access->DeleteContactL(KUidIccGlobalLndPhonebook, 2); + access->DeleteContactL(KUidUsimAppAdnPhonebook, 2); + access->DeleteContactL(KUidIccGlobalFdnPhonebook, 2); + + CleanupStack::PopAndDestroy(access); + } + + +/** + * Factory construction method. + * @return Pointer to CPhbkRequestSyncAndReadSimultaneouslyTest object + */ +CPhbkRequestSyncAndReadSimultaneouslyTest* CPhbkRequestSyncAndReadSimultaneouslyTest::NewL() + { + CPhbkRequestSyncAndReadSimultaneouslyTest* self = new(ELeave) CPhbkRequestSyncAndReadSimultaneouslyTest(); + return self; + } + +/** + * Default constructor. Each test step initialises it's own name. + */ +CPhbkRequestSyncAndReadSimultaneouslyTest::CPhbkRequestSyncAndReadSimultaneouslyTest() + { + SetTestStepName(_L("RequestSyncAndReadSimultaneouslyTest")); + } + +/** + * Request a synch and read simultaneously + */ +enum TVerdict CPhbkRequestSyncAndReadSimultaneouslyTest::doTestStepL() + { + SetSimTsyTestNumberL(9); + + // Ensure manual sync only + User::LeaveIfError(iSession.SetSyncMode(RPhoneBookSession::EManual)); + User::LeaveIfError(iSession.SetSyncMode(RPhoneBookSession::EManual, KUidIccGlobalSdnPhonebook)); + User::LeaveIfError(iSession.SetSyncMode(RPhoneBookSession::EManual, KUidIccGlobalLndPhonebook)); + User::LeaveIfError(iSession.SetSyncMode(RPhoneBookSession::EManual, KUidUsimAppAdnPhonebook)); + User::LeaveIfError(iSession.SetSyncMode(RPhoneBookSession::EManual, KUidIccGlobalFdnPhonebook)); + + TRequestStatus status; + // For each phonebook start the sync and attempt to read + + // Synchronise Global ADN + iSession.DoSynchronisation(status); + User::After(6000000); + iDb->SetDbViewContactType(KUidContactICCEntry); + // const CContactIdArray* sortedItems = iDb->SortedItemsL(); + + //Read Global ADN + CPhbkIntegrationTestUtility* access = CPhbkIntegrationTestUtility::NewL(); + CleanupStack::PushL(access); + access->ReadContactL(KUidIccGlobalAdnPhonebook, KTest9ICCSlotsADN); + CleanupStack::PopAndDestroy(access); + + //wait for end of sync + User::WaitForRequest(status); + TESTCHECKL(status.Int(), KErrNone); + + // Synchronise Global SDN + iSession.DoSynchronisation(status, KUidIccGlobalSdnPhonebook); + User::After(6000000); + iDb->SetDbViewContactType(KUidContactICCEntry); + // sortedItems = iDb->SortedItemsL(); + + //Read Global SDN + access = CPhbkIntegrationTestUtility::NewL(); + CleanupStack::PushL(access); + access->ReadContactL(KUidIccGlobalSdnPhonebook, KTest9ICCSlotsSDN); + CleanupStack::PopAndDestroy(access); + + //wait for end of sync + User::WaitForRequest(status); + TESTCHECKL(status.Int(), KErrNone); + + // Synchronise Global LND + iSession.DoSynchronisation(status, KUidIccGlobalLndPhonebook); + User::After(6000000); + iDb->SetDbViewContactType(KUidContactICCEntry); + // sortedItems = iDb->SortedItemsL(); + + //Read Global LND + access = CPhbkIntegrationTestUtility::NewL(); + CleanupStack::PushL(access); + access->ReadContactL(KUidIccGlobalLndPhonebook, KTest9ICCSlotsLND); + CleanupStack::PopAndDestroy(access); + + //wait for end of sync + User::WaitForRequest(status); + TESTCHECKL(status.Int(), KErrNone); + + // Synchronise Usim App + iSession.DoSynchronisation(status, KUidUsimAppAdnPhonebook); + User::After(6000000); + iDb->SetDbViewContactType(KUidContactICCEntry); + // sortedItems = iDb->SortedItemsL(); + + //Read Usim App + access = CPhbkIntegrationTestUtility::NewL(); + CleanupStack::PushL(access); + access->ReadContactL(KUidUsimAppAdnPhonebook, KTest9ICCSlotsUsim); + CleanupStack::PopAndDestroy(access); + + //wait for end of sync + User::WaitForRequest(status); + TESTCHECKL(status.Int(), KErrNone); + + // Synchronise Global FDN + iSession.DoSynchronisation(status, KUidIccGlobalFdnPhonebook); + User::After(6000000); + iDb->SetDbViewContactType(KUidContactICCEntry); + // sortedItems = iDb->SortedItemsL(); + + //Read Global FDN + access = CPhbkIntegrationTestUtility::NewL(); + CleanupStack::PushL(access); + access->ReadContactL(KUidIccGlobalFdnPhonebook, KTest9ICCSlotsFDN); + CleanupStack::PopAndDestroy(access); + + //wait for end of sync + User::WaitForRequest(status); + TESTCHECKL(status.Int(), KErrNone); + + return TestStepResult(); + } + + +/** + * Factory construction method. + * @return Pointer to CPhbkCheckServerThreadPriorityTest object + */ +CPhbkCheckServerThreadPriorityTest* CPhbkCheckServerThreadPriorityTest::NewL() + { + CPhbkCheckServerThreadPriorityTest* self = new(ELeave) CPhbkCheckServerThreadPriorityTest(); + return self; + } + +/** + * Default constructor. Each test step initialises it's own name. + */ +CPhbkCheckServerThreadPriorityTest::CPhbkCheckServerThreadPriorityTest() + { + SetTestStepName(_L("CheckServerThreadPriorityTest")); + } + +/** + * Confirm server thread priority + */ +enum TVerdict CPhbkCheckServerThreadPriorityTest::doTestStepL() + { + // Connect to the Phonebook Server + RPhoneBookSession session; + User::LeaveIfError(session.Connect()); + + RThread phoneBookServerThread; + _LIT(KThreadToFind,"*PhBkSyncServer*"); // PHBKSYNC_SVR_NAME + TFindThread find(KThreadToFind); + TFullName findName; + TInt findErr = find.Next(findName); + TESTCHECKL(findErr, KErrNone); + TInt ret = phoneBookServerThread.Open(findName); + + // Check the server thread priority level + TESTCHECKL(ret, KErrNone); + TThreadPriority serverPriority(phoneBookServerThread.Priority()); + TESTCHECK(serverPriority, EPriorityNormal); + + phoneBookServerThread.Close(); + session.Close(); + + return TestStepResult(); + } + + +/** + * Factory construction method. + * @return Pointer to CPhbkServerLostFileRecoveryTest object + */ +CPhbkServerLostFileRecoveryTest* CPhbkServerLostFileRecoveryTest::NewL() + { + CPhbkServerLostFileRecoveryTest* self = new(ELeave) CPhbkServerLostFileRecoveryTest(); + return self; + } + +/** + * Default constructor. Each test step initialises it's own name. + */ +CPhbkServerLostFileRecoveryTest::CPhbkServerLostFileRecoveryTest() + { + SetTestStepName(_L("ServerLostFileRecoveryTest")); + } + +/** + * Test server recovery after losing config files + */ +enum TVerdict CPhbkServerLostFileRecoveryTest::doTestStepL() + { + delete iDb; + iDb=NULL; + User::After(1000000); //1 second wait for contact to shut down + iSession.Close(); + ConfigurePhbkSyncToIdleL(); + + // *********************************************** + // First, test situation where there are no config + // files at all. + // *********************************************** + + // Delete all INI files and the contact database + TRAPD(ignore,CContactDatabase::DeleteDefaultFileL()); + RFs fsSession; + User::LeaveIfError(fsSession.Connect()); + CleanupClosePushL(fsSession); + + fsSession.Delete(KContactsModelIniFile); //ignore return value + fsSession.Delete(KPhbkSyncIniFile); //ignore return value + + // Verify that server starts okay + ConfigurePhbkSyncToFullL(); + TInt err = iSession.Connect(); + TESTCHECKL(err, KErrNone); + + // Perform synchronisation + TRAP(err, DoSyncL()); + TESTCHECKL(err, KErrNone); + + // Verify that contact database is available + TRAP(err, iDb = OpenOrCreateContactDatabaseL()); + TESTCHECKL(err, KErrNone); + User::After(1000000); //1 second wait + + // Get the groupId and template ID for each phonebook + TContactItemId groupIdADN(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(groupIdADN, + RPhoneBookSession::ESyncGroupId, + KUidIccGlobalAdnPhonebook)); + TESTCHECKCONDITIONL(groupIdADN != KNullContactId); + + TContactItemId groupIdSDN(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(groupIdSDN, + RPhoneBookSession::ESyncGroupId, + KUidIccGlobalSdnPhonebook)); + TESTCHECKCONDITIONL(groupIdSDN != KNullContactId); + + TContactItemId groupIdLND(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(groupIdLND, + RPhoneBookSession::ESyncGroupId, + KUidIccGlobalLndPhonebook)); + TESTCHECKCONDITIONL(groupIdLND != KNullContactId); + + TContactItemId groupIdUsim(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(groupIdUsim, + RPhoneBookSession::ESyncGroupId, + KUidUsimAppAdnPhonebook)); + TESTCHECKCONDITIONL(groupIdUsim != KNullContactId); + + TContactItemId tempIdADN(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(tempIdADN, + RPhoneBookSession::ESyncTemplateId, + KUidIccGlobalAdnPhonebook)); + TESTCHECKCONDITIONL(tempIdADN != KNullContactId); + + TContactItemId tempIdSDN(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(tempIdSDN, + RPhoneBookSession::ESyncTemplateId, + KUidIccGlobalSdnPhonebook)); + TESTCHECKCONDITIONL(tempIdSDN != KNullContactId); + + TContactItemId tempIdLND(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(tempIdLND, + RPhoneBookSession::ESyncTemplateId, + KUidIccGlobalLndPhonebook)); + TESTCHECKCONDITIONL(tempIdLND != KNullContactId); + + TContactItemId tempIdUsim(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(tempIdUsim, + RPhoneBookSession::ESyncTemplateId, + KUidUsimAppAdnPhonebook)); + TESTCHECKCONDITIONL(tempIdUsim != KNullContactId); + + // shutdown existing server session and close database + delete iDb; + iDb=NULL; + User::After(1000000); + iSession.Close(); + ConfigurePhbkSyncToIdleL(); + + // ************************************************ + // Now, remove phbksync INI file only and test that + // existing group and template ID's in the contact + // database are adopted as required. + // ************************************************ + + // Now remove phbksync INI file only + fsSession.Delete(KPhbkSyncIniFile); + + // Verify that server starts okay + ConfigurePhbkSyncToFullL(); + err = iSession.Connect(); + TESTCHECKL(err, KErrNone); + + // Perform synchronisation + TRAP(err, DoSyncL()); + TESTCHECKL(err, KErrNone); + + // Verify that contact database is available + TRAP(err, iDb = OpenOrCreateContactDatabaseL()); + TESTCHECKL(err, KErrNone); + User::After(1000000); //1 second wait + + // Check the groupId and template ID for each phonebook is the same as before + TContactItemId groupIdADN2(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(groupIdADN2, + RPhoneBookSession::ESyncGroupId, + KUidIccGlobalAdnPhonebook)); + TESTCHECKL(groupIdADN2, groupIdADN); + + TContactItemId groupIdSDN2(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(groupIdSDN2, + RPhoneBookSession::ESyncGroupId, + KUidIccGlobalSdnPhonebook)); + TESTCHECKL(groupIdSDN2, groupIdSDN); + + TContactItemId groupIdLND2(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(groupIdLND2, + RPhoneBookSession::ESyncGroupId, + KUidIccGlobalLndPhonebook)); + TESTCHECKL(groupIdLND2, groupIdLND); + + TContactItemId groupIdUsim2(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(groupIdUsim2, + RPhoneBookSession::ESyncGroupId, + KUidUsimAppAdnPhonebook)); + TESTCHECKL(groupIdUsim2, groupIdUsim); + + TContactItemId tempIdADN2(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(tempIdADN2, + RPhoneBookSession::ESyncTemplateId, + KUidIccGlobalAdnPhonebook)); + TESTCHECKL(tempIdADN2, tempIdADN); + + TContactItemId tempIdSDN2(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(tempIdSDN2, + RPhoneBookSession::ESyncTemplateId, + KUidIccGlobalSdnPhonebook)); + TESTCHECKL(tempIdSDN2, tempIdSDN); + + TContactItemId tempIdLND2(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(tempIdLND2, + RPhoneBookSession::ESyncTemplateId, + KUidIccGlobalLndPhonebook)); + TESTCHECKL(tempIdLND2, tempIdLND); + + TContactItemId tempIdUsim2(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(tempIdUsim2, + RPhoneBookSession::ESyncTemplateId, + KUidUsimAppAdnPhonebook)); + TESTCHECKL(tempIdUsim2, tempIdUsim); + + // shutdown existing server session and close database + delete iDb; + iDb=NULL; + User::After(1000000); + iSession.Close(); + ConfigurePhbkSyncToIdleL(); + + // ************************************************ + // Now, remove contact database only and test that + // group and template ID's in the phbksync INI file + // are re-created. This should result in same IDs + // as were created when we had no config files. + // ************************************************ + + // Now remove contact database only + TRAP(ignore,CContactDatabase::DeleteDefaultFileL()); + + // Verify that server starts okay + ConfigurePhbkSyncToFullL(); + err = iSession.Connect(); + TESTCHECKL(err, KErrNone); + + // Perform synchronisation + TRAP(err, DoSyncL()); + TESTCHECKL(err, KErrNone); + + // Verify that contact database is available + TRAP(err, iDb = OpenOrCreateContactDatabaseL()); + TESTCHECKL(err, KErrNone); + User::After(1000000); //1 second wait + + // Check the groupId and template ID for each phonebook is the same as before + TContactItemId groupIdADN3(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(groupIdADN3, + RPhoneBookSession::ESyncGroupId, + KUidIccGlobalAdnPhonebook)); + TESTCHECKL(groupIdADN3, groupIdADN); + + TContactItemId groupIdSDN3(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(groupIdSDN3, + RPhoneBookSession::ESyncGroupId, + KUidIccGlobalSdnPhonebook)); + TESTCHECKL(groupIdSDN3, groupIdSDN); + + TContactItemId groupIdLND3(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(groupIdLND3, + RPhoneBookSession::ESyncGroupId, + KUidIccGlobalLndPhonebook)); + TESTCHECKL(groupIdLND3, groupIdLND); + + TContactItemId groupIdUsim3(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(groupIdUsim3, + RPhoneBookSession::ESyncGroupId, + KUidUsimAppAdnPhonebook)); + TESTCHECKL(groupIdUsim3, groupIdUsim); + + TContactItemId tempIdADN3(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(tempIdADN3, + RPhoneBookSession::ESyncTemplateId, + KUidIccGlobalAdnPhonebook)); + TESTCHECKL(tempIdADN3, tempIdADN); + + TContactItemId tempIdSDN3(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(tempIdSDN3, + RPhoneBookSession::ESyncTemplateId, + KUidIccGlobalSdnPhonebook)); + TESTCHECKL(tempIdSDN3, tempIdSDN); + + TContactItemId tempIdLND3(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(tempIdLND3, + RPhoneBookSession::ESyncTemplateId, + KUidIccGlobalLndPhonebook)); + TESTCHECKL(tempIdLND3, tempIdLND); + + TContactItemId tempIdUsim3(KNullContactId); + TRAP(err, iSession.GetPhoneBookId(tempIdUsim3, + RPhoneBookSession::ESyncTemplateId, + KUidUsimAppAdnPhonebook)); + TESTCHECKL(tempIdUsim3, tempIdUsim); + + CleanupStack::PopAndDestroy(&fsSession); + return TestStepResult(); + } + + +/** + * Factory construction method. + * @return Pointer to CPhbkIntegrationBackupTest object. + */ +CPhbkIntegrationBackupTest* CPhbkIntegrationBackupTest::NewL() + { + CPhbkIntegrationBackupTest* self = new(ELeave) CPhbkIntegrationBackupTest(); + return self; + } + +/** + * Default constructor. + */ +CPhbkIntegrationBackupTest::CPhbkIntegrationBackupTest() + { + SetTestStepName(_L("IntegrationBackupTest")); + } + +/** + * Destructor. + */ +CPhbkIntegrationBackupTest::~CPhbkIntegrationBackupTest() + { + // NOP + } + +/** + * Simulate a backup and restore of the Contacts DB. This will require + * the PhBkSync server to unconfigure and close its connection to the + * Contacts database. + */ +enum TVerdict CPhbkIntegrationBackupTest::doTestStepL() + { + // + // Setup the SIM.TSY configuration and then close TE_CntSync's handle + // to the Contacts DB as it'll interfer with this test. Future tests + // will re-open it automatically. + // + SetSyncModeL(RPhoneBookSession::EManual); + CheckSyncModeL(RPhoneBookSession::EManual); + SetSimTsyTestNumberL(0); + DoSyncL(); + CheckCacheStateL(RPhoneBookSession::ECacheValid); + + delete iDb; + iDb = NULL; + + // + // Open the file server... + // + RFs fsSession; + User::LeaveIfError(fsSession.Connect()); + CleanupClosePushL(fsSession); + CFileMan* fileManager = CFileMan::NewL(fsSession); + CleanupStack::PushL(fileManager); + + // + // Try and copy the Contacts DB file while it is in use... + // + TInt result, resultSqlite; + + result = fileManager->Copy(KContactsDBFile, KContactsDBFileBackup); + resultSqlite = fileManager->Copy(KContactsSqliteDBFile, KContactsSqliteDBFileBackup); + TESTCHECKCONDITION((result == KErrInUse) || (resultSqlite == KErrInUse)); + + result = fileManager->Copy(KPhbkSyncIniFile, KPhbkSyncIniFileBackup); + TESTCHECK(result, KErrNone); + + // + // SQLite uses a different filename. This is stored here if in use. + // + const TDesC& databaseName = (resultSqlite == KErrInUse) ? KContactsSqliteDBFile() : KContactsDBFile(); + const TDesC& databaseBackupName = (resultSqlite == KErrInUse) ? KContactsSqliteDBFileBackup() : KContactsDBFileBackup(); + + // + // Notify the PhBkSync server that a backup is about to take place and + // that the server should release the Contacts DB... + // + iSecureBackupEngine->SetBURModeL(TDriveList(_L8("C")), + EBURBackupFull, EBackupBase); + + RPhoneBookSession::TPhonebookSyncMode dummySyncMode; + + result = KErrNone; + while (result == KErrNone) + { + result = iSession.GetSyncMode(dummySyncMode); + if (result == KErrNone) + { + User::After(1); + } + } + TESTCHECK(result, KErrNotReady); + + // + // Now copy the Contacts DB and PhBkSync INI files... + // + result = fileManager->Copy(databaseName, databaseBackupName); + TESTCHECK(result, KErrNone); + result = fileManager->Copy(KPhbkSyncIniFile, KPhbkSyncIniFileBackup); + TESTCHECK(result, KErrNone); + + // + // Check that a sync notification cannot be posted in this state... + // + TRequestStatus status; + + iSession.NotifyPhBkCacheStateChange(status, KUidIccGlobalAdnPhonebook); + User::WaitForRequest(status); + TESTCHECK(status.Int(), KErrNotReady); + + // + // Notify the PhBkSync server that the backup is over. PhBkSync will + // restart and continue as before... + // + iSecureBackupEngine->SetBURModeL(TDriveList(_L8("C")), + EBURNormal, ENoBackup); + + result = KErrNotReady; + while (result == KErrNotReady) + { + result = iSession.GetSyncMode(dummySyncMode); + if (result == KErrNotReady) + { + User::After(1); + } + } + TESTCHECK(result, KErrNone); + + // + // Check PhBkSync server is still running okay... + // + CheckCacheStateL(RPhoneBookSession::EUnsynchronised); + DoSyncL(); + CheckCacheStateL(RPhoneBookSession::ECacheValid); + + // + // Change the settings in the INI file to test that the restore works... + // + SetSyncModeL(RPhoneBookSession::EAutoSameIcc); + CheckSyncModeL(RPhoneBookSession::EAutoSameIcc); + + // + // Notify the PhBkSync server that a restore is about to take place and + // that the server should release the Contacts DB... + // + iSecureBackupEngine->SetBURModeL(TDriveList(_L8("C")), + EBURRestorePartial, EBackupIncrement); + + result = KErrNone; + while (result == KErrNone) + { + result = iSession.GetSyncMode(dummySyncMode); + if (result == KErrNone) + { + User::After(1); + } + } + TESTCHECK(result, KErrNotReady); + + // + // Delete the Contacts DB and PhBkSync INI files and rename the backup files + // to the original names. + // + result = fsSession.Delete(databaseName); + TESTCHECK(result, KErrNone); + result = fsSession.Delete(KPhbkSyncIniFile); + TESTCHECK(result, KErrNone); + result = fsSession.Rename(databaseBackupName, databaseName); + TESTCHECK(result, KErrNone); + result = fsSession.Rename(KPhbkSyncIniFileBackup, KPhbkSyncIniFile); + TESTCHECK(result, KErrNone); + + // + // Notify the PhBkSync server that the restore is over. PhBkSync will + // restart and continue as it did before the backup... + // + iSecureBackupEngine->SetBURModeL(TDriveList(_L8("C")), + EBURNormal, ENoBackup); + + result = KErrNotReady; + while (result == KErrNotReady) + { + result = iSession.GetSyncMode(dummySyncMode); + if (result == KErrNotReady) + { + User::After(1); + } + } + TESTCHECK(result, KErrNone); + + // + // Check PhBkSync server is running as before the backup... + // + CheckSyncModeL(RPhoneBookSession::EManual); + + CheckCacheStateL(RPhoneBookSession::EUnsynchronised); + DoSyncL(); + CheckCacheStateL(RPhoneBookSession::ECacheValid); + + // + // Clean up and finish the test... + // + CleanupStack::PopAndDestroy(fileManager); + CleanupStack::PopAndDestroy(&fsSession); + + return TestStepResult(); + } // CPhbkIntegrationBackupTest::doTestStepL