diff -r e8c1ea2c6496 -r 8758140453c0 localisation/apparchitecture/tef/T_BackupStep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/localisation/apparchitecture/tef/T_BackupStep.cpp Thu Jan 21 12:53:44 2010 +0000 @@ -0,0 +1,919 @@ +// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of the License "Symbian Foundation License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// Performs Tests on Backup server.\n +// +// + + + +/** + @file + @internalComponent - Internal Symbian test code +*/ + +#include +#include +#include +#include +#include +#include +#include +#include "T_BackupStep.h" + + + +CTestActive::CTestActive() +: CActive(EPriorityIdle*2) + { + CActiveScheduler::Add(this); + } + +CTestActive::~CTestActive() + { + Cancel(); + } + +void CTestActive::DoCancel() + { + TRequestStatus* s=&iStatus; + User::RequestComplete(s, KErrNone); + } + +void CTestActive::StartL() + { + iReport = NULL; + SetActive(); + } + + +/** + Auxiliary Fn for Test Case ID T-BackupStep-testGetsCallbackOnBackupStartL, + T-BackupStep-testGetsCallbackOnBackupEndL, + T-BackupStep-testGetsCallbackOnBackupStartInSecondWrapperL, + T-BackupStep-testGetsCallbackOnBackupWrapperKillL, and + T-BackupStep-testGetsCallbackOnBackupWrapperKillOtherL + + This function is used to set the event request to the AO and + to set that AO active.\n + +*/ +void CTestActive::StartL(TRequestStatus& aRequestStatus) + { + iReport = &aRequestStatus; + SetActive(); + } + +void CTestActive::RunL() + { + CActiveScheduler::Stop(); + } + +// Class to test the n-th recieved event from the backup server is the same as the event +// the object is initialised with +CTestBackupOperationObserver::CTestBackupOperationObserver(const TBackupOperationAttributes& aEvent, CTestExecuteLogger& aLogger) : CTestActive(), iEvent(aEvent), iCount(1) + { + iLogger=aLogger; + } +CTestBackupOperationObserver::CTestBackupOperationObserver(const TBackupOperationAttributes& aEvent, TInt aCount, CTestExecuteLogger& aLogger) : CTestActive(), iEvent(aEvent), iCount(aCount) + { + iLogger=aLogger; + } + + +/** + Auxiliary Fn for Test Case ID T-BackupStep-testGetsCallbackOnBackupStartL, + T-BackupStep-testGetsCallbackOnBackupEndL, + T-BackupStep-testGetsCallbackOnBackupStartInSecondWrapperL, + T-BackupStep-testGetsCallbackOnBackupWrapperKillL, and + T-BackupStep-testGetsCallbackOnBackupWrapperKillOtherL + + This function is overridden from MBackupOperationObserver and is called + when a backup or restore operation either starts or ends. The function is used + to receive signals that tell what backup operation completed.\n + +*/ +void CTestBackupOperationObserver::HandleBackupOperationEventL(const TBackupOperationAttributes& aBackupOperationAttributes) + { + const TInt KOneOfOurEvents = 12321; + if(iCount!=KOneOfOurEvents) + { + INFO_PRINTF2(_L("Got event #%d from backup server; ignoring this one\n"), iCount+1); + } + else + { + iCount=0; + if(iReport) + { + User::RequestComplete(iReport, aBackupOperationAttributes.iOperation); + INFO_PRINTF1(_L("Got event from backup server; Completing...\n")); + } + else + { + INFO_PRINTF1(_L("Got event from backup server; iReport not set...testing...\n")); + } + } + } + +void CTestBackupOperationObserver::SetReadyToGo() +{ + const TInt KOneOfOurEvents = 12321; + iCount=KOneOfOurEvents; +} + + +/** + Auxiliary Fn for all test cases + + This function creates an Active Object (AO).Sets the AO to + be active. Starts the active scheduler to complete any pending requests + and flushes all requests from the scheduler list.\n + +*/ +void CT_BackupStep::FlushSchedulerQueueL() +{ + CTestActive* active = new(ELeave) CTestActive(); + CleanupStack::PushL(active); + RTimer timer; + timer.CreateLocal(); + timer.After(active->iStatus,500000); + active->StartL(); + CActiveScheduler::Start(); + CleanupStack::PopAndDestroy(1);//active +} + + +/** + @SYMTestCaseID T-BackupStep-testGetsCallbackOnBackupStartL + + @SYMPREQ + + @SYMTestCaseDesc Test whether backup server signals the test backup observer + on backup start operation. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The test creates an object of test observer to observe for + start backup event and registers the specified observer to be notified + when a backup operation starts by calling RegisterBackupOperationObserverL(). + Set attributes to indicate start of backup operation. Flush the scheduler + of all pending requests. Set start backup event to the AO. Notify the + server of backup operation using NotifyBackupOperationL(). + Start the active scheduler to receive signal for start event from backup + server.\n + API Calls:\n + CBaBackupSessionWrapper::RegisterBackupOperationObserverL(MBackupOperationObserver& aBackupOperationObserver)\n + CBaBackupSessionWrapper::NotifyBackupOperationL(const TBackupOperationAttributes& aBackupOperationAttributes)\n + CBaBackupSessionWrapper::DeRegisterBackupOperationObserver(MBackupOperationObserver& aBackupOperationObserver)\n + + @SYMTestExpectedResults The test should complete with Backup server signaling the observer + when the Backup operation starts.\n + + */ +void CT_BackupStep::testGetsCallbackOnBackupStartL() + { + const TBackupOperationAttributes gEventStart(MBackupObserver::EReleaseLockNoAccess, MBackupOperationObserver::EStart); + CTestBackupOperationObserver* backupObserver = new(ELeave) CTestBackupOperationObserver(gEventStart, Logger()); + CleanupStack::PushL(backupObserver); + gWrapper->RegisterBackupOperationObserverL(*backupObserver); + FlushSchedulerQueueL(); + + backupObserver->StartL(backupObserver->iStatus); + gWrapper->NotifyBackupOperationL(gEventStart); + backupObserver->SetReadyToGo(); + CActiveScheduler::Start(); + TEST(backupObserver->iStatus == gEventStart.iOperation); + + gWrapper->DeRegisterBackupOperationObserver(*backupObserver); + CleanupStack::PopAndDestroy();//backupObserver; + } + + +/** + @SYMTestCaseID T-BackupStep-testGetsCallbackOnBackupEndL + + @SYMPREQ + + @SYMTestCaseDesc Test whether backup server signals the test backupobserver on + backup end operation. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The test creates an object of test observer to observe for end + of backup event and registers the specified observer to be notified when a + backup operation ends by calling RegisterBackupOperationObserverL().Set + attributes to indicate start and end of backup operation. Flush the scheduler + from all pending requests. Set start backup event to the AO. Notify the + server of a start backup operation using NotifyBackupOperationL(). + Start the active scheduler to receive signal for start event from backup + server. Now set end of backup event to the AO. Notify server of an end + backup operation using NotifyBackupOperationL(). Start the active + scheduler to receive signal for end of backup event from backup server.\n + API Calls:\n + CBaBackupSessionWrapper::RegisterBackupOperationObserverL(MBackupOperationObserver& aBackupOperationObserver)\n + CBaBackupSessionWrapper::NotifyBackupOperationL(const TBackupOperationAttributes& aBackupOperationAttributes)\n + CBaBackupSessionWrapper::DeRegisterBackupOperationObserver(MBackupOperationObserver& aBackupOperationObserver)\n + + @SYMTestExpectedResults The test should complete with Backup server signaling the observer + when the Backup operation ends. + + */ +void CT_BackupStep::testGetsCallbackOnBackupEndL() + { + const TBackupOperationAttributes gEventStart(MBackupObserver::EReleaseLockNoAccess, MBackupOperationObserver::EStart); + const TBackupOperationAttributes gEventEnd(MBackupObserver::ETakeLock, MBackupOperationObserver::EEnd); + CTestBackupOperationObserver* backupObserver = new(ELeave) CTestBackupOperationObserver(gEventEnd, Logger()); + CleanupStack::PushL(backupObserver); + gWrapper->RegisterBackupOperationObserverL(*backupObserver); + FlushSchedulerQueueL(); + + backupObserver->StartL(backupObserver->iStatus); + gWrapper->NotifyBackupOperationL(gEventStart); + backupObserver->SetReadyToGo(); + CActiveScheduler::Start(); + TEST(backupObserver->iStatus == gEventStart.iOperation); + + backupObserver->StartL(backupObserver->iStatus); + gWrapper->NotifyBackupOperationL(gEventEnd); + backupObserver->SetReadyToGo(); + CActiveScheduler::Start(); + TEST(backupObserver->iStatus == gEventEnd.iOperation); + + gWrapper->DeRegisterBackupOperationObserver(*backupObserver); + CleanupStack::PopAndDestroy();//backupObserver; + } + + +/** + @SYMTestCaseID T-BackupStep-testGetsCallbackOnBackupStartInSecondWrapperL + + @SYMPREQ + + @SYMTestCaseDesc Test whether signal for start backup operation can be + received by a second observer that is not associated + with the wrapper object that issued the request for start + of backup. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The test creates two test observers and two wrappers to the + backup server. Set attributes to indicate start of backup operation. + Register & associate each observer with each session wrappers that needs + to be notified of backup start operation, issued by the respective wrappers + by calling RegisterBackupOperationObserverL(). Using the first wrapper, + notify the server to start backup. Verify that second observer receives + the notification for start of server.\n + API Calls:\n + CBaBackupSessionWrapper::NewL()\n + CBaBackupSessionWrapper::RegisterBackupOperationObserverL(MBackupOperationObserver& aBackupOperationObserver)\n + CBaBackupSessionWrapper::NotifyBackupOperationL(const TBackupOperationAttributes& aBackupOperationAttributes)\n + CBaBackupSessionWrapper::DeRegisterBackupOperationObserver(MBackupOperationObserver& aBackupOperationObserver)\n + + @SYMTestExpectedResults The test should confirm that second observer receives + the signal for backup start operation issued by the first wrapper object. + + */ +void CT_BackupStep::testGetsCallbackOnBackupStartInSecondWrapperL() + { + const TBackupOperationAttributes gEventStart(MBackupObserver::EReleaseLockNoAccess, MBackupOperationObserver::EStart); + CTestBackupOperationObserver* backupObserver = new(ELeave) CTestBackupOperationObserver(gEventStart, Logger()); + CleanupStack::PushL(backupObserver); + gWrapper->RegisterBackupOperationObserverL(*backupObserver); + FlushSchedulerQueueL(); + + CBaBackupSessionWrapper* secondWrapper=CBaBackupSessionWrapper::NewL(); + CleanupStack::PushL(secondWrapper); + + CTestBackupOperationObserver* backupObserver2 = new(ELeave) CTestBackupOperationObserver(gEventStart, Logger()); + CleanupStack::PushL(backupObserver2); + secondWrapper->RegisterBackupOperationObserverL(*backupObserver2); + FlushSchedulerQueueL(); + + backupObserver2->StartL(backupObserver2->iStatus); + gWrapper->NotifyBackupOperationL(gEventStart); + backupObserver2->SetReadyToGo(); + CActiveScheduler::Start(); + TEST(backupObserver2->iStatus == gEventStart.iOperation); + + gWrapper->DeRegisterBackupOperationObserver(*backupObserver); + secondWrapper->DeRegisterBackupOperationObserver(*backupObserver2); + CleanupStack::PopAndDestroy(3);//backupObserver, backupObserver2, secondWrapper + } + + +/** + @SYMTestCaseID T-BackupStep-testGetsCallbackOnBackupWrapperKillL + + @SYMPREQ + + @SYMTestCaseDesc Test if MBackupOperationObserver::EAbort event is received + when wrapper to the backup server is destroyed immediately + after backup start operation is requested. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Create a test backup observer. Register the observer to receive + event from server. Create a second wrapper to the backup server. Use the + second wrapper to notify the server to start backup. After receiving signal + for start of backup, destroy the second wrapper. Observe event received + from the server.\n + API Calls:\n + CBaBackupSessionWrapper::NewL()\n + CBaBackupSessionWrapper::RegisterBackupOperationObserverL(MBackupOperationObserver& aBackupOperationObserver)\n + CBaBackupSessionWrapper::NotifyBackupOperationL(const TBackupOperationAttributes& aBackupOperationAttributes)\n + CBaBackupSessionWrapper::DeRegisterBackupOperationObserver(MBackupOperationObserver& aBackupOperationObserver)\n + + @SYMTestExpectedResults Test confirms that event MBackupOperationObserver::EAbort + is received. + + */ +void CT_BackupStep::testGetsCallbackOnBackupWrapperKillL() + { + const TBackupOperationAttributes gEventStart(MBackupObserver::EReleaseLockNoAccess, MBackupOperationObserver::EStart); + const TBackupOperationAttributes gEventEnd(MBackupObserver::ETakeLock, MBackupOperationObserver::EEnd); + const TBackupOperationAttributes gEventAbort(MBackupObserver::ETakeLock, MBackupOperationObserver::EAbort); + CTestBackupOperationObserver* backupObserver = new(ELeave) CTestBackupOperationObserver(gEventEnd, Logger()); + CleanupStack::PushL(backupObserver); + gWrapper->RegisterBackupOperationObserverL(*backupObserver); + FlushSchedulerQueueL(); + + CBaBackupSessionWrapper* secondWrapper=CBaBackupSessionWrapper::NewL(); + CleanupStack::PushL(secondWrapper); + + backupObserver->StartL(backupObserver->iStatus); + secondWrapper->NotifyBackupOperationL(gEventStart); + backupObserver->SetReadyToGo(); + CActiveScheduler::Start(); + TEST(backupObserver->iStatus == gEventStart.iOperation); + + backupObserver->StartL(backupObserver->iStatus); + CleanupStack::PopAndDestroy();//secondWrapper + backupObserver->SetReadyToGo(); + CActiveScheduler::Start(); + TEST(backupObserver->iStatus == gEventAbort.iOperation); + + gWrapper->DeRegisterBackupOperationObserver(*backupObserver); + CleanupStack::PopAndDestroy(1);//backupObserver + } + + +/** + @SYMTestCaseID T-BackupStep-testGetsCallbackOnBackupWrapperKillOtherL + + @SYMPREQ + + @SYMTestCaseDesc Test that the backup is not terminated after a backup start event, + which is followed by destruction of any wrapper other than the wrapper + which requested the backup start event. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Create a test observer. Register the observer with the server. + Create second and third wrappers to the backup server besides the global + wrapper. Use the second observer to start backup. Observe that the event for + start of backup is received. Destroy the third wrapper created. Observe + event received from the server. Notify the server to observe for event + MBackupOperationObserver::ENone.Observe the event received. Notify the server + to stop backup. Observe the event received. Destroy the second observer. + Note that this destruction causes an abort event.\n + API Calls:\n + CBaBackupSessionWrapper::NewL()\n + CBaBackupSessionWrapper::RegisterBackupOperationObserverL(MBackupOperationObserver& aBackupOperationObserver)\n + CBaBackupSessionWrapper::NotifyBackupOperationL(const TBackupOperationAttributes& aBackupOperationAttributes)\n + CBaBackupSessionWrapper::DeRegisterBackupOperationObserver(MBackupOperationObserver& aBackupOperationObserver)\n + + @SYMTestExpectedResults Test confirms that backup will not be terminated by + destruction of wrapper object that did not initiate the back up process, + after the backup operation has started. + + */ +void CT_BackupStep::testGetsCallbackOnBackupWrapperKillOtherL() + { + const TBackupOperationAttributes gEventStart(MBackupObserver::EReleaseLockNoAccess, MBackupOperationObserver::EStart); + const TBackupOperationAttributes gEventEnd(MBackupObserver::ETakeLock, MBackupOperationObserver::EEnd); + const TBackupOperationAttributes gEventNone(MBackupObserver::ETakeLock, MBackupOperationObserver::ENone); + + CTestBackupOperationObserver* backupObserver = new(ELeave) CTestBackupOperationObserver(gEventEnd, Logger()); + CleanupStack::PushL(backupObserver); + gWrapper->RegisterBackupOperationObserverL(*backupObserver); + FlushSchedulerQueueL(); + + CBaBackupSessionWrapper* secondWrapper=CBaBackupSessionWrapper::NewL(); + CleanupStack::PushL(secondWrapper); // This one starts the backup + + CBaBackupSessionWrapper* thirdWrapper=CBaBackupSessionWrapper::NewL(); + CleanupStack::PushL(thirdWrapper); // This one gets destroyed + FlushSchedulerQueueL(); + + backupObserver->StartL(backupObserver->iStatus); + secondWrapper->NotifyBackupOperationL(gEventStart);; + backupObserver->SetReadyToGo(); + CActiveScheduler::Start(); + TEST(backupObserver->iStatus == gEventStart.iOperation); + + backupObserver->StartL(backupObserver->iStatus); + CleanupStack::PopAndDestroy(thirdWrapper);//thirdWrapper + TEST(backupObserver->iStatus == gEventStart.iOperation); // + secondWrapper->NotifyBackupOperationL(gEventNone); + backupObserver->SetReadyToGo(); + CActiveScheduler::Start(); + TEST(backupObserver->iStatus == gEventNone.iOperation); + + backupObserver->StartL(backupObserver->iStatus); + secondWrapper->NotifyBackupOperationL(gEventEnd); + backupObserver->SetReadyToGo(); + CActiveScheduler::Start(); + TEST(backupObserver->iStatus == gEventEnd.iOperation); + + backupObserver->StartL(backupObserver->iStatus); + CleanupStack::PopAndDestroy(secondWrapper);//secondWrapper + TEST(backupObserver->iStatus == gEventEnd.iOperation); + CleanupStack::PopAndDestroy();//backupObserver + gWrapper->DeRegisterBackupOperationObserver(*backupObserver); + } + + +CThreadLaunchCounter::CThreadLaunchCounter() : CActive(0) + { + CActiveScheduler::Add(this); + gCount = 0; + } + +CThreadLaunchCounter::~CThreadLaunchCounter() + { + if(IsActive()) + Cancel(); + } + +void CThreadLaunchCounter::Start() + { + iStatus=KRequestPending; + gCount++; + SetActive(); + } + +void CThreadLaunchCounter::RunL() + { + if(--gCount==0) + CActiveScheduler::Stop(); + delete this; + } + + +/** + @SYMTestCaseID T-BackupStep-testMultipleClientsL + + @SYMPREQ + + @SYMTestCaseDesc Test multiple clients accessing the Backup server. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The test creates multiple threads to make multiple clients + access the backup server simultaneously. Each of the threads execute the + thread function BackupMultipleTestThreadEntry() to create a wrapper object + to the backup server so that a backup operation can be carried out. + The test thus emulates a multiple client scenario.\n + API Calls:\n + RThread::Create(const TDesC& aName, TThreadFunction aFunction, TInt aStackSize, RAllocator* aHeap, TAny* aPtr, TOwnerType aType=EOwnerProcess)\n + RThread::Resume() const\n + RThread::Logon(TRequestStatus& aStatus) const\n + RThread::Close()\n + + @SYMTestExpectedResults The test completes creating multiple threads and tests + multi-client interaction with the backup server. + + */ +void CT_BackupStep::testMultipleClientsL() + { + const TInt KNumMultipleThreads=1; + _LIT(KMultiThreadBaseName,"Multithread"); + const TInt KBackupServerStackSize =0x3000; // 16k + CBackupTestThreadParams Params; + Params.Step = this; + for(TInt i=0;i name(KMultiThreadBaseName); + name.AppendNum(i); + TInt64 theSeed = 12312312; + Params.seed=Math::Rand(theSeed); + User::LeaveIfError(thread.Create(name, BackupMultipleTestThreadEntry, KBackupServerStackSize, NULL, &Params)); + thread.Resume(); + thread.Logon(threadCounter->iStatus); + threadCounter->Start(); + thread.Close(); + } + User::After(2000000); + CActiveScheduler::Start();//runs until all the CThreadLaunchCounter are completed + User::After(2000000); + CleanupStack::Pop(KNumMultipleThreads); + } + + + +TRequestStatus CT_BackupStep::testExtraRestartLockedOutL() +// +// Tests that we are only able to restart the apps once - no extra threads around! +// + { +//vm + const TBackupOperationAttributes gEventStart(MBackupObserver::EReleaseLockNoAccess, MBackupOperationObserver::EStart); + gWrapper->NotifyBackupOperationL(gEventStart); +//vm + _LIT(KAppRestarterThreadName,"AppRestarterThread"); + TRequestStatus status; + gWrapper->CloseAll(MBackupObserver::EReleaseLockNoAccess, status); + User::WaitForRequest(status); +///vm + if(status != KErrNone) + { + return status; + } + + const TBackupOperationAttributes gEventEnd(MBackupObserver::ETakeLock, MBackupOperationObserver::EEnd); + gWrapper->NotifyBackupOperationL(gEventEnd); +//// + + gWrapper->RestartAll(); + gWrapper->RestartAll(); + gWrapper->RestartAll(); + gWrapper->RestartAll(); + + TInt err; + err=KErrNone; + TFullName name; + TFindThread find(KAppRestarterThreadName); + err=find.Next(name); + if(err==KErrNotFound) + { + INFO_PRINTF1(_L("Error in test code timing - need to try again\n")); + + return status; + } + gWrapper->RestartAll(); + gWrapper->RestartAll(); + + RThread thread; + err=thread.Open(name); + TInt ignoreId = thread.Id(); + if(err==KErrNotFound) + { + INFO_PRINTF1(_L("Error in test code timing - need to try again\n")); + return status; + } + thread.Logon(status); + User::WaitForRequest(status); + thread.Close(); + + TFindThread find1(KAppRestarterThreadName); + while( (err=find1.Next(name)) != KErrNotFound) + { + RThread thread; + if(thread.Open(name)==KErrNone) + { + TInt id=thread.Id(); + TEST(id == ignoreId); + thread.Close(); + } + } + return status; + } + + +/** + @SYMTestCaseID T-BackupStep-testRestartAppsL + + @SYMPREQ + + @SYMTestCaseDesc Test whether CBaBackupSessionWrapper::RestartAll() unlocks + file locks (MBackupObserver::ETakeLock flag) for the + registered files locked by CloseAll(). + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Call TFindThread::Next() continuously to find all threads and + append id of each of these threads to a list. + Call CBaBackupSessionWrapper::CloseAll() to close all non-system + applications and call all observers to release or stop writing to the + registered files. Call CBaBackupSessionWrapper::RestartAll(). + Call TFindThread::Next() continuously to find all threads. Compare the id + of each thread to the id stored in the list to find a match.\n + API Calls:\n + CBaBackupSessionWrapper::RestartAll()\n + CBaBackupSessionWrapper::CloseAll(MBackupObserver::TFileLockFlags aFlags, TRequestStatus& aStatus)\n + + @SYMTestExpectedResults Test that CBaBackupSessionWrapper::RestartAll() take + back file locks (MBackupObserver::ETakeLock flag) for the registered files + locked by CloseAll(). + + */ +void CT_BackupStep::testRestartAppsL() + { +//vm + const TBackupOperationAttributes gEventStart(MBackupObserver::EReleaseLockNoAccess, MBackupOperationObserver::EStart); + gWrapper->NotifyBackupOperationL(gEventStart); +//vm + + TFindThread find; + INFO_PRINTF1(_L("\nRestartApps.......")); + TFullName name; + RArray idArray; + CleanupClosePushL(idArray); + while(find.Next(name)!=KErrNotFound) + { + INFO_PRINTF1(_L("\nAppending thread id.......")); + RThread thread; + thread.Open(name); + TInt id=thread.Id(); + idArray.Append(id); + thread.Close(); + INFO_PRINTF1(_L("\nCompleted.")); + } + + INFO_PRINTF1(_L("\nGWrapper: Close all.......")); + TRequestStatus status; + gWrapper->CloseAll(MBackupObserver::EReleaseLockNoAccess, status); + + User::WaitForRequest(status); + + INFO_PRINTF1(_L("\nWait.")); + User::After(1000000); + +///vm + const TBackupOperationAttributes gEventEnd(MBackupObserver::ETakeLock, MBackupOperationObserver::EEnd); + gWrapper->NotifyBackupOperationL(gEventEnd); + +//// + + INFO_PRINTF1(_L("\nGWrapper: Restart all.......")); + gWrapper->RestartAll(); + INFO_PRINTF1(_L("\nGWrapper: Restart all.....Completed")); + INFO_PRINTF1(_L("\nGWrapper: Close all.......Completed.")); + + TFindThread find2; + + while(find2.Next(name)!=KErrNotFound) + { +// Create a thread in the calling process + INFO_PRINTF1(_L("\nGet Thread ID.......")); + RThread thread; + thread.Open(name); + TInt id=thread.Id(); + thread.Close(); + INFO_PRINTF1(_L("\nGet Thread ID......Completed.")); + + INFO_PRINTF1(_L("\nFind process ID in idArray")); + if(idArray.Find(id)==KErrNone) + { + TInt temp =0; + TEST(temp==0); // no instance of this thread is found + } + INFO_PRINTF1(_L("\nFind process ID in idArray.....Completed.")); + } + CleanupStack::PopAndDestroy(&idArray); //idArray + + + INFO_PRINTF1(_L("\nRestartApps completed.")); + } + + + +/** + Auxiliary Fn for all Test Cases. + + The method initiates all the tests to be performed. + +*/ +void CT_BackupStep::doTestsL() + { + const TBackupOperationAttributes gEventEnd(MBackupObserver::ETakeLock, MBackupOperationObserver::EEnd); + TRAPD(err,gWrapper=CBaBackupSessionWrapper::NewL()); + if(err!=KErrNone) + { + INFO_PRINTF1(_L("Couldn't open session wrapper\n")); + User::Leave(err); + } + INFO_PRINTF1(_L("Backup session test 1\n")); + TRAP(err,gWrapper->NotifyBackupOperationL(gEventEnd)); + if(err!=KErrNone) + { + INFO_PRINTF1(_L("Couldn't notify backup operation\n")); + User::Leave(err); + } + + FlushSchedulerQueueL(); + testGetsCallbackOnBackupStartL(); + + gWrapper->NotifyBackupOperationL(gEventEnd); + FlushSchedulerQueueL(); + INFO_PRINTF1(_L("Backup session test 2\n")); + testGetsCallbackOnBackupEndL(); + + gWrapper->NotifyBackupOperationL(gEventEnd); + FlushSchedulerQueueL(); + INFO_PRINTF1(_L("Backup session test 3\n")); + testGetsCallbackOnBackupStartInSecondWrapperL(); + + gWrapper->NotifyBackupOperationL(gEventEnd); + FlushSchedulerQueueL(); + INFO_PRINTF1(_L("Backup session test 4\n")); + testGetsCallbackOnBackupWrapperKillL(); + + gWrapper->NotifyBackupOperationL(gEventEnd); + FlushSchedulerQueueL(); + INFO_PRINTF1(_L("Backup session test 5\n")); + testGetsCallbackOnBackupWrapperKillOtherL(); + + gWrapper->NotifyBackupOperationL(gEventEnd); + FlushSchedulerQueueL(); + INFO_PRINTF1(_L("Backup session test 6\n")); + /*TRequestStatus status = testExtraRestartLockedOutL(); + + if(status=KErrNone) + { + gWrapper->NotifyBackupOperationL(gEventEnd); + FlushSchedulerQueueL(); + INFO_PRINTF1(_L("Backup session test 7\n")); + testRestartAppsL(); + + gWrapper->NotifyBackupOperationL(gEventEnd); + INFO_PRINTF1(_L("Backup session test 8\n")); + testMultipleClientsL(); + }*/ + delete gWrapper; + + } + + +/** + Auxiliary Fn for Test Case ID T-BackupStep-testMultipleClientsL + + Entry point for the thread used to test multiple simultaneous wrapper + sessions with the backup server. This method calls + DoBackupMultipleTestThreadEntryL() method to perform this task.\n + +*/ +GLDEF_C TInt CT_BackupStep::BackupMultipleTestThreadEntry(TAny* aPtr) + { + CActiveScheduler* scheduler=new CActiveScheduler; + if (!scheduler) + return KErrNoMemory; + CTrapCleanup* trapCleanup=CTrapCleanup::New(); + if (!trapCleanup) + { + delete scheduler; + return KErrNoMemory; + } + CActiveScheduler::Install(scheduler); + + CBackupTestThreadParams& threadParams = *(CBackupTestThreadParams*)aPtr; + TRAPD(err,threadParams.Step->DoBackupMultipleTestThreadEntryL(/*aPtr*/)); + + delete CActiveScheduler::Current(); + delete trapCleanup; + return err; + } + + +/** + Auxiliary Fn for Test Case ID T-BackupStep-testMultipleClientsL + + The method is called by the thread function BackupMultipleTestThreadEntry() + to create a wrapper session to perform some backup operation.\n + +*/ +TInt CT_BackupStep::DoBackupMultipleTestThreadEntryL(/*TAny* aSeed*/) + { + const TBackupOperationAttributes gEventEnd(MBackupObserver::ETakeLock, MBackupOperationObserver::EEnd); + CBaBackupSessionWrapper* wrapper=CBaBackupSessionWrapper::NewL(); + CleanupStack::PushL(wrapper); + + CTestBackupOperationObserver* backupObserver = new(ELeave) CTestBackupOperationObserver(gEventEnd, Logger()); + CleanupStack::PushL(backupObserver); + wrapper->RegisterBackupOperationObserverL(*backupObserver); + FlushSchedulerQueueL(); + wrapper->NotifyBackupOperationL(gEventEnd); + + wrapper->DeRegisterBackupOperationObserver(*backupObserver); + CleanupStack::PopAndDestroy(2);//backupObserver, wrapper + return KErrNone; + } + + +/** + Auxiliary Fn for entire Test Step + + This method creates and installs an active scheduler for tests. + +*/ +void CT_BackupStep::SetupSchedulerL() + { + testScheduler = new (ELeave) CActiveScheduler; + CleanupStack::PushL( testScheduler ); + CActiveScheduler::Install( testScheduler ); + } + +/** + Auxiliary Fn for entire Test Step + + This method removes the active scheduler from the cleanup stack and + destroys it on completion of the tests. + +*/ +void CT_BackupStep::CloseScheduler() + { + CleanupStack::PopAndDestroy(); // Scheduler + testScheduler = NULL; + } + +//********************************** +// Global +//********************************** + + +void CT_BackupStep::doMainL() + { + SetupSchedulerL(); + doTestsL(); + CloseScheduler(); + } + + +CT_BackupStep::~CT_BackupStep() +/** + Destructor + */ + { + } + +CT_BackupStep::CT_BackupStep() +/** + Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KT_BackupStep); + } + +TVerdict CT_BackupStep::doTestStepPreambleL() +/** + @return - TVerdict code + Override of base class virtual + */ + { + return TestStepResult(); + } + +TVerdict CT_BackupStep::doTestStepPostambleL() +/** + @return - TVerdict code + Override of base class virtual + */ + { + return TestStepResult(); + } + + +TVerdict CT_BackupStep::doTestStepL() +/** + @return - TVerdict code + Override of base class virtual + */ +{ + INFO_PRINTF1(_L("Testing Apparc...T_Backup")); + // + __UHEAP_MARK; + TRAPD(ret,doMainL()); + TEST(ret==KErrNone); + __UHEAP_MARKEND; + + INFO_PRINTF1(_L("Test completed!")); + return TestStepResult(); +}