--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lowlevellibsandfws/apputils/tsrc/T_BackupSrv.cpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,767 @@
+// Copyright (c) 1997-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 <e32debug.h>
+#include <e32test.h>
+#include <babackup.h>
+#include "T_backupSrv.h"
+LOCAL_D RTest MainTest(_L(" T_BackupSrv.cpp"));
+
+_LIT(KFileName1, "FileName1");
+_LIT(KFileName2, "FileName2");
+_LIT(KFileName3, "FileName3");
+_LIT(KFileName4, "FileName4");
+
+// Nasty global convenience function
+LOCAL_D void LogThread()
+{
+ TBuf<150> buf((RThread().Name()));
+ RDebug::Print(_L("*** Currently in thread : "));
+ RDebug::Print(buf);
+}
+
+//
+// class CBackupOperationObserver
+//
+CBackupOperationObserver* CBackupOperationObserver::NewL(TInt aObserverNumber)
+ {
+ LogThread();
+ RDebug::Print(_L("CBackupOperationObserver::NewL"));
+
+ CBackupOperationObserver* self = new (ELeave) CBackupOperationObserver();
+ CleanupStack::PushL(self);
+ self->ConstructL(aObserverNumber);
+ CleanupStack::Pop();
+ return self;
+ }
+
+CBackupOperationObserver::CBackupOperationObserver()
+ : CActive(0)
+ { ; }
+
+CBackupOperationObserver::~CBackupOperationObserver()
+ {
+ LogThread();
+ RDebug::Print(_L("CBackupOperationObserver::~CBackupOperationObserver"));
+
+ iBackupSession->DeRegisterBackupOperationObserver(*this);
+ delete iBackupSession;
+
+ delete iLocalRTest;
+ }
+
+void CBackupOperationObserver::ConstructL(TInt aObserverNumber)
+ {
+ // Set up the AO callback
+ CActiveScheduler::Add(this);
+ SetActive();
+ iStatus = KRequestPending;
+
+ // Create a new session for this backup notification observer
+ iBackupSession = CBaBackupSessionWrapper::NewL();
+ iBackupSession->RegisterBackupOperationObserverL(*this);
+ iObserverNumber = aObserverNumber;
+ iLocalRTest = new (ELeave) RTest(_L("BackupOperationObserver"));
+ }
+
+void CBackupOperationObserver::HandleBackupOperationEventL(const TBackupOperationAttributes& aBackupOperationAttributes)
+ {
+ LogThread();
+ RDebug::Print(_L("CBackupOperationObserver::HandleBackupOperationEventL"));
+
+ TBuf<150> buf;
+ buf.Format(_L("Backup observer number %d received a notification of operation type %d and file lock type: %d\n"),iObserverNumber, aBackupOperationAttributes.iOperation, aBackupOperationAttributes.iFileFlag);
+ RDebug::Print(buf);
+ }
+
+void CBackupOperationObserver::DoCancel()
+ { ; }
+
+void CBackupOperationObserver::RunL()
+ {
+ // Okay - we're back in the right thread!
+ LogThread();
+ RDebug::Print(_L("CBackupOperationObserver::RunL"));
+
+ // Finished with this object
+ delete this;
+
+ // And the active scheduler in this thread
+ CActiveScheduler::Current()->Stop();
+
+ }
+
+void CBackupOperationObserver::Kill(RThread* aThread)
+ {
+ LogThread();
+ RDebug::Print(_L("CBackupFileObserver::Kill"));
+
+ // Trigger the Active Object locally - in a different thread!
+ TRequestStatus* tempStatus=(&iStatus);
+ aThread->RequestComplete(tempStatus, KErrNone);
+ }
+
+//
+// class CBackupFileObserver
+//
+
+CBackupFileObserver::CBackupFileObserver()
+ : CActive(0)
+ { ; }
+
+void CBackupFileObserver::ConstructL(TInt aFileObserverNumber)
+ {
+ // Set up the AO callback
+ CActiveScheduler::Add(this);
+ SetActive();
+ iStatus = KRequestPending;
+
+ // Create a new session for this file lock observer
+ iBackupSession = CBaBackupSessionWrapper::NewL();
+ iFileObserverNumber = aFileObserverNumber;
+ iFileLocksChanged = 0;
+ iFileLockState = ELocked;
+ iLocalRTest = new (ELeave) RTest(_L("BackupFileObserver"));
+ }
+
+CBackupFileObserver* CBackupFileObserver::NewL(TInt aFileObserverNumber)
+ {
+ LogThread();
+ RDebug::Print(_L("CBackupFileObserver::NewL"));
+
+ CBackupFileObserver* self=new(ELeave) CBackupFileObserver();
+ CleanupStack::PushL(self);
+ self->ConstructL(aFileObserverNumber);
+ CleanupStack::Pop();
+ return self;
+ }
+
+CBackupFileObserver::~CBackupFileObserver()
+ {
+ LogThread();
+ RDebug::Print(_L("CBackupFileObserver::~CBackupFileObserver"));
+
+ delete iBackupSession;
+
+ delete iLocalRTest;
+ }
+
+void CBackupFileObserver::AddFileL(TInt aFileNumber)
+ {
+ LogThread();
+ RDebug::Print(_L("CBackupFileObserver::AddFileL"));
+
+ // We base the filename of the number of thread in the RArray
+ iFileName.Format(_L("FileName%d"), aFileNumber);
+
+ iBackupSession->RegisterFileL(iFileName,*this);
+ }
+
+TInt CBackupFileObserver::GetFileLocksChanged()
+ {
+ return iFileLocksChanged;
+ }
+
+void CBackupFileObserver::ZeroFileLocksChanged()
+ {
+ iFileLocksChanged = 0;
+ }
+
+void CBackupFileObserver::SetDelay(TBool aDelay)
+{
+ iDelay = aDelay;
+}
+
+void CBackupFileObserver::ChangeFileLockL(const TDesC& aFileName,TFileLockFlags aFlags)
+ {
+ LogThread();
+ RDebug::Print(_L("BackupFileObserver::ChangeFileLockL"));
+
+ // Keep a count of how many release notifications there have been
+ if (aFlags != MBackupObserver::ETakeLock)
+ {
+ iFileLocksChanged++;
+ }
+
+ // If delay is set then insert wait now
+ if (iDelay && (!(aFileName.Compare(KFileName1))))
+ {
+ User::After(10000000);
+ }
+
+ // Check this file is the one for this observer - if not fail test;
+ if (iFileName.Compare(aFileName))
+ {
+ RDebug::Print(_L("\nReceived notification for non-registered file!"));
+ (*iLocalRTest)(EFalse);
+ }
+
+ // Update the local file lock array
+ CBackupFileObserver::TFileLock flag = (CBackupFileObserver::TFileLock) aFlags;
+ iFileLockState = flag;
+
+ // Test output
+ TBuf<150> buf;
+ buf.Format(_L("File backup observer number %d was notified for file %S of file lock type: %d\n"),iFileObserverNumber, &aFileName, flag);
+ RDebug::Print(buf);
+ }
+
+void CBackupFileObserver::DoCancel()
+ { ; }
+
+void CBackupFileObserver::RunL()
+ {
+ // Okay - we're back in the right thread!
+ LogThread();
+ RDebug::Print(_L("CBackupFileObserver::RunL"));
+
+ // Finished with this object
+ delete this;
+
+ // And the active scheduler in this thread
+ CActiveScheduler::Current()->Stop();
+
+ }
+
+void CBackupFileObserver::Kill(RThread* aThread)
+ {
+ LogThread();
+ RDebug::Print(_L("CBackupFileObserver::Kill"));
+
+ // Trigger the Active Object locally - in a different thread!
+ TRequestStatus* tempStatus=(&iStatus);
+ aThread->RequestComplete(tempStatus, KErrNone);
+ }
+
+//
+// class CBackupTestsStateMachine
+//
+
+CBackupTestsStateMachine* CBackupTestsStateMachine::NewL()
+ {
+ CBackupTestsStateMachine* self = new (ELeave) CBackupTestsStateMachine();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+CBackupTestsStateMachine::CBackupTestsStateMachine()
+ : CActive(0)
+{ ; }
+
+void CBackupTestsStateMachine::ConstructL()
+ {
+ // Set up the RTest for this thread and display we're started
+ iLocalRTest = new (ELeave) RTest(_L("T_BACKUP_SRV"));
+ iLocalRTest->Title();
+
+ // Set the ititial state
+ iState = EStateMachineStart;
+
+ // Zero the EndBackupRecursionCount (see below)
+ iEndBackupRecursionCount = 0;
+
+ // Add this to the Active Scheduler and set us active
+ CActiveScheduler::Add(this);
+ SetActive();
+
+ // Create the backup "command" session
+ iBackupSession = CBaBackupSessionWrapper::NewL();
+
+ // Set up the mutex
+ iMutex.CreateLocal();
+ }
+
+// Observers need to have their own thread
+void CBackupTestsStateMachine::CreateObserversThreadsL()
+ {
+ RDebug::Print(_L("Starting observers threads"));
+
+ TInt i;
+ TBuf<30> newThreadNames;
+ TInt error;
+ for (i = 0; i<4 ; i++)
+ {
+ // Backup observer
+ iBackupObserverThreads.AppendL(new (ELeave) RThread);
+ newThreadNames.Format(_L("Backup Observer Thread %d"), i+1);
+ error = iBackupObserverThreads[i]->Create(newThreadNames, CBackupTestsStateMachine::BackupObserversThreadStartL, 0x2000, NULL, (TAny*)this);
+ (*iLocalRTest)(error==KErrNone);
+ iBackupObserverThreads[i]->Resume();
+
+ // File observer
+ iFileObserverThreads.AppendL(new (ELeave) RThread);
+ newThreadNames.Format(_L("File Observer Thread %d"), i+1);
+ error = iFileObserverThreads[i]->Create(newThreadNames, CBackupTestsStateMachine::FileObserversThreadStartL, 0x2000, NULL, (TAny*)this);
+
+ (*iLocalRTest)(error==KErrNone);
+ iFileObserverThreads[i]->Resume();
+
+ // Brief delay to let the observer threads get started
+ User::After(1000000);
+ }
+
+ }
+
+// Static starting function for the backup observers threads
+TInt CBackupTestsStateMachine::BackupObserversThreadStartL(TAny* aPtr)
+ {
+ // Create the Cleanup Stack and Active Scheduler for this thread
+
+ CTrapCleanup* theTrapCleanup = CTrapCleanup::New();
+ CActiveScheduler *activeScheduler = new CActiveScheduler;
+ CActiveScheduler::Install(activeScheduler);
+
+ // Create the observer instances
+ CBackupTestsStateMachine* objectPtr = static_cast<CBackupTestsStateMachine*>(aPtr);
+ TRAPD(error, objectPtr->CreateBackupObserverInstanceL());
+ User::LeaveIfError(error);
+
+ // Go to Active Scheduler main loop for this thread
+ CActiveScheduler::Start();
+
+ // And we're done
+ delete activeScheduler;
+ delete theTrapCleanup;
+
+ return KErrNone;
+ }
+
+// Static starting function for the file observers threads
+TInt CBackupTestsStateMachine::FileObserversThreadStartL(TAny* aPtr)
+{
+ // Create the Cleanup Stack and Active Scheduler for this thread
+ CTrapCleanup* theTrapCleanup = CTrapCleanup::New();
+ CActiveScheduler* activeScheduler = new CActiveScheduler;
+ CActiveScheduler::Install(activeScheduler);
+
+ // Create the observer instances
+ CBackupTestsStateMachine* objectPtr = static_cast<CBackupTestsStateMachine*>(aPtr);
+ TRAPD(error, objectPtr->CreateFileObserverInstanceL());
+ User::LeaveIfError(error);
+
+ // Go to Active Scheduler main loop for this thread
+ CActiveScheduler::Start();
+
+ // And we're done
+ delete activeScheduler;
+ delete theTrapCleanup;
+
+ return KErrNone;
+}
+
+void CBackupTestsStateMachine::CreateBackupObserverInstanceL()
+ {
+ iMutex.Wait();
+
+ TInt count = iBackupObserverThreads.Count();
+
+ // Create the new object instance (one object per thread)
+ // We base the thread number of the number of thread in the RArray
+ CBackupOperationObserver* newObserver = CBackupOperationObserver::NewL(count);
+ iBackupObservers.AppendL(newObserver);
+
+ iMutex.Signal();
+ }
+
+void CBackupTestsStateMachine::CreateFileObserverInstanceL()
+{
+ iMutex.Wait();
+
+ TInt count = iBackupFileObservers.Count();
+
+ // Create the new object instance (one object per thread)
+ CBackupFileObserver* newObserver = CBackupFileObserver::NewL(count + 1);
+ iBackupFileObservers.AppendL(newObserver);
+
+ // Register the file for this thread / instance
+ iBackupFileObservers[count]->AddFileL(count + 1);
+
+ iMutex.Signal();
+}
+
+// State Machine destructor
+CBackupTestsStateMachine::~CBackupTestsStateMachine()
+ {
+ // Close our session into the backup server
+ delete iBackupSession;
+
+ // Delete all the observers (only 3 of each of by this point)
+ TInt i;
+
+ for (i = 0; i<3 ; i++)
+ {
+ iBackupObservers[i]->Kill(iBackupObserverThreads[i]);
+ iBackupFileObservers[i]->Kill(iFileObserverThreads[i]);
+ User::After(50000000);
+ }
+ iBackupObservers.Close();
+ iBackupFileObservers.Close();
+
+ // Kill the observer threads
+ for (i = 0; i<3 ; i++)
+
+ {
+ iBackupObserverThreads[i]->Kill(KErrNone);
+ delete iBackupObserverThreads[i];
+ iFileObserverThreads[i]->Kill(KErrNone);
+ delete iFileObserverThreads[i];
+ }
+ iBackupObserverThreads.Close();
+ iFileObserverThreads.Close();
+
+ // Display we're finished
+ iLocalRTest->Close();
+ delete iLocalRTest;
+
+ // Cancel this is it's active
+ if (IsActive())
+ {
+ Cancel();
+ }
+ }
+
+// Common starting function for all test-related calls to CloseAll
+void CBackupTestsStateMachine::CloseAllStartL(StateMachineState aNextState, MBackupObserver::TFileLockFlags aFlag)
+ {
+ StartBackupL();
+ iState = aNextState;
+ iBackupSession->CloseAll(aFlag, iStatus);
+ }
+
+// Common ending function for all test-related calls to CloseAll
+void CBackupTestsStateMachine::CloseAllEndL(StateMachineState aNextState, TInt aExpectedNotifications)
+ {
+ iState = aNextState;
+ SignalEndBackupL();
+ EndBackup(aExpectedNotifications, ETrue);
+ iLocalRTest->End();
+ Complete();
+ }
+
+// State machine call back - get here by calls to Complete and returns for asynchronous server calls
+void CBackupTestsStateMachine::RunL()
+ {
+ switch(iState)
+ {
+ case EStateMachineStart:
+ // Create observers threads
+ CreateObserversThreadsL();
+ iState = ECloseAllNormalReadOnly;
+ Complete();
+ break;
+ case ECloseAllNormalReadOnly:
+ iLocalRTest->Start(_L("\nCloseAllFiles normal ReadOnly\n"));
+ CloseAllStartL(ECloseAllNormalReadOnlyReturned, MBackupObserver::EReleaseLockReadOnly);
+ break;
+ case ECloseAllNormalReadOnlyReturned:
+ CloseAllEndL(ECloseAllNormalNoAccess, 4);
+ break;
+ case ECloseAllNormalNoAccess:
+ iLocalRTest->Start(_L("\nCloseAllFiles normal NoAccess\n"));
+ CloseAllStartL(ECloseAllNormalNoAccessReturned, MBackupObserver::EReleaseLockNoAccess);
+ break;
+ case ECloseAllNormalNoAccessReturned:
+ CloseAllEndL(ECloseAllDelayReadOnly, 4);
+ break;
+ case ECloseAllDelayReadOnly:
+ iLocalRTest->Start(_L("\nCloseAllFiles delay ReadOnly\n"));
+ iBackupFileObservers[0]->SetDelay(ETrue);
+ CloseAllStartL(ECloseAllDelayReadOnlyReturned, MBackupObserver::EReleaseLockReadOnly);
+ break;
+ case ECloseAllDelayReadOnlyReturned:
+ iBackupFileObservers[0]->SetDelay(EFalse);
+ CloseAllEndL(ECloseAllDelayNoAccess, 4);
+ // Nice long wait for the timer to expire in the other thread
+ User::After(10000000);
+ break;
+ case ECloseAllDelayNoAccess:
+ iLocalRTest->Start(_L("\nCloseAllFiles delay NoAccess\n"));
+ iBackupFileObservers[0]->SetDelay(ETrue);
+ CloseAllStartL(ECloseAllDelayNoAccessReturned, MBackupObserver::EReleaseLockNoAccess);
+ break;
+ case ECloseAllDelayNoAccessReturned:
+ iBackupFileObservers[0]->SetDelay(EFalse);
+ CloseAllEndL(ECloseAllDropFileSession, 4);
+ // Nice long wait for the timer to expire in the other thread
+ User::After(10000000);
+ break;
+ case ECloseAllDropFileSession:
+ iLocalRTest->Start(_L("\nCloseAllFiles dropping file session\n"));
+ // Drop one of the file registration / observer sessions
+ iBackupFileObservers[0]->Kill(iFileObserverThreads[0]);
+ // Nice long wait for the observer to be killed in the other thread
+ User::After(10000000);
+ // Remove it from the list
+ iBackupFileObservers.Remove(0);
+ // Kill the thread
+ iFileObserverThreads[0]->Kill(KErrNone);
+ delete iFileObserverThreads[0];
+ iFileObserverThreads.Remove(0);
+ // All done - start this sub-test
+ CloseAllStartL(ECloseAllDropFileSessionReturned, MBackupObserver::EReleaseLockReadOnly);
+ break;
+ case ECloseAllDropFileSessionReturned:
+ CloseAllEndL(ECloseAllDropBackupObserverSession, 3);
+ break;
+ case ECloseAllDropBackupObserverSession:
+ iLocalRTest->Start(_L("\nCloseAllFiles dropping backup session\n"));
+ // Drop one of the backup observer sessions
+ iBackupObservers[0]->Kill(iBackupObserverThreads[0]);
+ // Nice long wait for the observer to be killed in the other thread
+ User::After(10000000);
+ // Remove it from the list
+ iBackupObservers.Remove(0);
+ // Kill the thread
+ iBackupObserverThreads[0]->Kill(KErrNone);
+ delete iBackupObserverThreads[0];
+ iBackupObserverThreads.Remove(0);
+ // All done - start this sub-test
+ CloseAllStartL(ECloseAllDropBackupObserverSessionReturned, MBackupObserver::EReleaseLockReadOnly);
+ break;
+ case ECloseAllDropBackupObserverSessionReturned:
+ CloseAllEndL(ESingleFileTests, 3);
+ break;
+ case ESingleFileTests:
+ iLocalRTest->Start(_L("\nSingle file lock tests\n"));
+ StartBackupL();
+ SingleFileLockTestsL();
+ SignalEndBackupL();
+ // Can call EndBackup synchronously here as nothing in SingleFileLockTests is asynchronous
+ EndBackup(3, EFalse);
+ iLocalRTest->End();
+ iState = ENoBackupSessionSingleFileTests;
+ Complete();
+ break;
+ // Required to cover the situation when the backup server is used purely for message signalling
+ // For example in the LogEng compnent
+ case ENoBackupSessionSingleFileTests:
+ iLocalRTest->Start(_L("\nNo backup session single file lock tests\n"));
+ SingleFileLockTestsL();
+ // Can call EndBackup synchronously here as nothing in SingleFileLockTests is asynchronous
+ EndBackup(3, EFalse);
+ iLocalRTest->End();
+ iState = EStateMachineEnd;
+ Complete();
+ break;
+ case EStateMachineEnd:
+ RDebug::Print(_L("\nEnd of state machine\n"));
+ End();
+ break;
+ default:
+ RDebug::Print(_L("\nCBackupTestsStateMachine::RunL problem"));
+ break;
+ }
+ if (!IsActive())
+ {
+ SetActive();
+ }
+ }
+
+void CBackupTestsStateMachine::DoCancel()
+ {
+ Complete();
+ }
+
+void CBackupTestsStateMachine::RunError()
+ { ; }
+
+// Common function to start a backup
+void CBackupTestsStateMachine::StartBackupL()
+ {
+ TBackupOperationAttributes attribs;
+ attribs.iFileFlag=MBackupObserver::EReleaseLockNoAccess;
+ attribs.iOperation=MBackupOperationObserver::EStart;
+ iBackupSession->NotifyBackupOperationL(attribs);
+ RDebug::Print(_L("\nStarting backup\n"));
+ }
+
+void CBackupTestsStateMachine::SignalEndBackupL()
+ {
+ // Tell the server the backup is over
+ TBackupOperationAttributes attribs;
+ attribs.iFileFlag=MBackupObserver::EReleaseLockNoAccess;
+ attribs.iOperation=MBackupOperationObserver::EEnd;
+ iBackupSession->NotifyBackupOperationL(attribs);
+ }
+
+// This function works in two ways. If oneTimeOnly is ETrue then all file lock
+// change notifications must have been received before this function is called.
+// If oneTimeOnly is EFalse this function recursively calls itself (a finate number
+// of times) until all notifications have arrived (this happens with single file testing)
+void CBackupTestsStateMachine::EndBackup(TInt aFileLockChangesExpected, TBool oneTimeOnly)
+ {
+ // Get the total notification count so far
+ TInt numberOfObservers = iBackupFileObservers.Count();
+ TInt totalNotificationCount = 0;
+ for (TInt i=0; i<numberOfObservers ; i++)
+ {
+ totalNotificationCount += iBackupFileObservers[i]->GetFileLocksChanged();
+ }
+ if (aFileLockChangesExpected == totalNotificationCount)
+ {
+ // Reset the recursion count
+ iEndBackupRecursionCount = 0;
+
+ // Zero the notification counts in the file lock observers
+ for (TInt i = 0 ; i<numberOfObservers ; i++)
+ {
+ iBackupFileObservers[i]->ZeroFileLocksChanged();
+ }
+
+ // Debug output
+ TBuf<100> buf;
+ buf.Format(_L("\nBackup finished sucsessfully on recusion count %d of EndBackup\n"), iEndBackupRecursionCount);
+ RDebug::Print(buf);
+ }
+ else if (oneTimeOnly)
+ {
+ // No second chances - fail here
+ (*iLocalRTest)(EFalse);
+ }
+ else
+ {
+ // Give it 5 more seconds (in 10 .5 second iterations) for the notifications to arrive
+ User::After(500000);
+ // 5 seconds is more than enough (timeouts in server should have gone off by now anyway)
+ iEndBackupRecursionCount++;
+ if (iEndBackupRecursionCount > 10)
+ {
+ (*iLocalRTest)(EFalse);
+ }
+ // Recursively calling isn't great but it needs to leave the function so the AO can run
+ EndBackup(aFileLockChangesExpected, EFalse);
+ }
+
+ }
+
+void CBackupTestsStateMachine::Complete()
+ {
+ // Trigger the Active Object locally
+ TRequestStatus* tempStatus=(&iStatus);
+ User::RequestComplete(tempStatus, KErrNone);
+ }
+
+void CBackupTestsStateMachine::Start()
+ {
+ // Time to start testing
+ RDebug::Print(_L("\nCBackupTestsStateMachine::Start"));
+ Complete();
+ }
+
+void CBackupTestsStateMachine::End()
+ {
+ // We're done testing - kill the Active Scheduler
+ RDebug::Print(_L("\nAll test complete\n"));
+ Cancel();
+ CActiveScheduler::Current()->Stop();
+ }
+
+void CBackupTestsStateMachine::SingleFileLockTestsL()
+ {
+ TFileName file;
+
+ // File 1
+ file.Copy(KFileName1);
+ iLocalRTest->Next(file);
+
+ iBackupSession->CloseFileL(KFileName1, MBackupObserver::EReleaseLockReadOnly);
+ iBackupSession->RestartFile(file);
+
+// iBackupSession->CloseFileL(KFileName1, MBackupObserver::EReleaseLockNoAccess);
+// iBackupSession->RestartFile(file);
+
+ // File 2
+ file.Copy(KFileName2);
+ iLocalRTest->Next(file);
+
+ iBackupSession->CloseFileL(KFileName2, MBackupObserver::EReleaseLockReadOnly);
+ iBackupSession->RestartFile(file);
+
+// iBackupSession->CloseFileL(KFileName2, MBackupObserver::EReleaseLockNoAccess);
+// iBackupSession->RestartFile(file);
+
+ // File 3
+ file.Copy(KFileName3);
+ iLocalRTest->Next(file);
+
+ iBackupSession->CloseFileL(KFileName3, MBackupObserver::EReleaseLockReadOnly);
+ iBackupSession->RestartFile(file);
+
+// iBackupSession->CloseFileL(KFileName3, MBackupObserver::EReleaseLockNoAccess);
+// iBackupSession->RestartFile(file);
+
+ // File 3
+ file.Copy(KFileName4);
+ iLocalRTest->Next(file);
+
+ iBackupSession->CloseFileL(KFileName4, MBackupObserver::EReleaseLockReadOnly);
+ iBackupSession->RestartFile(file);
+
+// iBackupSession->CloseFileL(KFileName4, MBackupObserver::EReleaseLockNoAccess);
+// iBackupSession->RestartFile(file);
+ }
+
+/**
+@SYMTestCaseID SYSLIB-BAFL-CT-0467
+@SYMTestCaseDesc Tests the functionality of CBaBackupSessionWrapper class
+@SYMTestPriority High
+@SYMTestActions Tests for the enabling backup of files
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+LOCAL_D void StartTestsL()
+ {
+ // For the sake of logging let's start off by renaming the main "command" thread
+ RThread().RenameMe(_L("Main thread"));
+
+ // Create state machine
+ CBackupTestsStateMachine* stateMachine = CBackupTestsStateMachine::NewL();
+
+ // Kick it off
+ stateMachine->Start();
+
+ // Start the Active Scheduler
+ CActiveScheduler::Start();
+
+ // Clean up the state machine
+ delete stateMachine;
+ }
+
+TInt E32Main()
+ {
+ MainTest.Title();
+ MainTest.Start(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0467 Loading Device"));
+
+ __UHEAP_MARK;
+
+ CTrapCleanup* theTrapCleanup=CTrapCleanup::New();
+ CActiveScheduler *activeScheduler=new CActiveScheduler;
+ CActiveScheduler::Install(activeScheduler);
+
+ TRAPD(error, StartTestsL());
+ User::LeaveIfError(error);
+
+ delete activeScheduler;
+ delete theTrapCleanup;
+
+ __UHEAP_MARKEND;
+
+ MainTest.End();
+
+
+ return(KErrNone);
+ }