diff -r 000000000000 -r 2f259fa3e83a commonuisupport/uikon/test/teiksrv/tbackup/tbackup.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/commonuisupport/uikon/test/teiksrv/tbackup/tbackup.cpp	Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,1937 @@
+// 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 "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:
+// Tests CBaBackupSessionWrapper APIs and observers for backup server.
+// 
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+#include <eikenv.h>
+#include <coecntrl.h>
+#include <basched.h>
+#include <babackup.h>
+#include <eikappui.h>
+#include <eikdef.h>
+#include <eikapp.h>
+#include <eikdoc.h>
+#include <techview/eikon.hrh>
+#include <techview/eiktxlbx.h>
+#include <techview/eiktxlbm.h>
+#include <techview/eikchlst.h>
+#include <techview/eikclb.h>
+#include <techview/eikclbd.h>
+#include <techview/eikdialg.h>
+#include <techview/eikcapc.h>
+#include <apgwgnam.h>
+#include <apgtask.h>
+#include <apgcli.h>
+#include <eikcoctl.rsg>
+#include <techview/eikchkbx.h>
+#include <eikmsg.h>
+#include <techview/eikhopbt.h>
+#include <uiklafgt/eikcore.rsg>
+#include <ecom/ecom.h>
+
+
+#include "tbackup.hrh"
+#include <tbackup.rsg>
+
+
+#include "tbackup.h"
+
+_LIT(KBackupFile1,"foo1");
+_LIT(KBackupFile2,"foo2");
+_LIT(KBackupFile3,"foo3");
+_LIT(KObserverStr, "Observer %d:");
+_LIT(KBackupOpMsg, "Backup Operation running");
+_LIT(KRegistrationDlgTitle, "Register and DeRegister Observers");
+
+_LIT(KTBackupResourceFilePath, "z:\\system\\test\\tbackup\\tbackup.rsc");
+
+
+
+/**********************************************
+ 
+ 
+ 
+ 	CBackupDialogBase
+ 
+ 
+ 
+************************************************/
+CBackupDialogBase::CBackupDialogBase(CDesCArray& aFiles,TOperationGranularity& aGranularity,TDes& aFileName)
+	: iFiles(aFiles), iGranularity(aGranularity), iFileName(aFileName)
+/**
+   Constructor
+ */
+	{}
+
+
+/**
+   Auxiliary Function for all Test Cases
+  
+   This method is an override from CEikDialog.It performs pre-layout dialog
+   initialisation.
+  
+ */
+void CBackupDialogBase::PreLayoutDynInitL()
+	{
+	SetHorOptionButListCurrentSet(EDlgBackupCloseOpButList,EDlgBackupCloseAll);
+	CEikChoiceList* list=static_cast<CEikChoiceList*>(Control(EDlgBackupFileList));
+	list->SetArrayExternalOwnership(ETrue);
+	list->SetArrayL(&iFiles);
+	UpdateFileListDimmedState();
+	}
+
+
+/**
+   Auxiliary Function for all Test Cases
+  
+   This method is an override from CEikDialog. Handles dialog button press 'All'
+   and 'File' to select a single file or all files to be closed by the dialog.
+  
+ */
+TBool CBackupDialogBase::OkToExitL(TInt /*aButtonId*/)
+	{
+	if (HorOptionButListCurrentSet(EDlgBackupCloseOpButList)==EDlgBackupCloseAll)
+		{
+		iGranularity=EAll;
+		}
+	else
+		{
+		iGranularity=ESingleFile;
+		const CEikChoiceList* list=static_cast<CEikChoiceList*>(Control(EDlgBackupFileList));
+		iFileName=iFiles[list->CurrentItem()];
+		}
+	return ETrue;
+	}
+
+/**
+   Auxiliary Function for all Test Cases
+  
+   This method is an override from CEikDialog. This function is called when a
+   control event of type EEventStateChanged is received by the dialog from one
+   of its component controls. 
+  
+ */
+void CBackupDialogBase::HandleControlStateChangeL(TInt aControlId)
+	{
+	if (aControlId==EDlgBackupCloseOpButList)
+		{
+		UpdateFileListDimmedState();
+		}
+	}
+
+/**
+   Auxiliary Function for all Test Cases
+  
+   This method is an override from CEikDialog. This method dims and deactivates
+   the file choice list on the dialog.
+  
+ */
+void CBackupDialogBase::UpdateFileListDimmedState()
+	{
+	const TBool dimFileList=(HorOptionButListCurrentSet(EDlgBackupCloseOpButList)==EDlgBackupCloseAll);
+	const CEikChoiceList* list=static_cast<CEikChoiceList*>(Control(EDlgBackupFileList));
+	const TBool fileListDimmed=list->IsDimmed();
+	if (dimFileList!=fileListDimmed)
+		{
+		SetLineDimmedNow(EDlgBackupFileList,dimFileList);
+		}
+	}
+
+
+/**********************************************
+ 
+ 
+ 
+ 	CBackupCloseDialog
+ 
+ 
+ 
+************************************************/
+
+/**
+  Auxiliary function for TestCaseID tbackup-CmdCloseL
+  
+  This method initialises and launches the backup close dialog.
+  
+ */
+TBool CBackupCloseDialog::RunDlgLD(CDesCArray& aFiles,CBackupDialogBase::TOperationGranularity& aGranularity,
+										TDes& aFileName,MBackupObserver::TFileLockFlags& aFlag)
+	{ // static
+	CBackupCloseDialog* dlg=new(ELeave) CBackupCloseDialog(aFiles,aGranularity,aFileName,aFlag);
+	return dlg->ExecuteLD(R_TBACKUP_FILE_OPTIONS);
+	}
+
+CBackupCloseDialog::CBackupCloseDialog(CDesCArray& aFiles,CBackupDialogBase::TOperationGranularity& aGranularity,
+										TDes& aFileName,MBackupObserver::TFileLockFlags& aFlag)
+	: CBackupDialogBase(aFiles,aGranularity,aFileName), iFileFlag(aFlag)
+/**
+   Constructor
+ */
+	{
+	}
+/**
+   Auxiliary function for TestCaseID tbackup-CmdCloseL
+  
+   This method is an override from CEikDialog.It performs pre-layout dialog
+   initialisation.
+  
+ */
+void CBackupCloseDialog::PreLayoutDynInitL()
+	{
+	SetHorOptionButListCurrentSet(EDlgBackupFlagOpButList,EDlgBackupReadOnly);
+	CBackupDialogBase::PreLayoutDynInitL();
+	}
+
+/**
+   Auxiliary function for TestCaseID tbackup-CmdCloseL
+  
+   This method is an override from CEikDialog. It is used to specify 'Read only' or
+   'No access' file locks while CloseAll() & CloseFileL() APIs are invoked.
+  
+ */
+TBool CBackupCloseDialog::OkToExitL(TInt aButtonId)
+	{
+	if (HorOptionButListCurrentSet(EDlgBackupFlagOpButList)==EDlgBackupReadOnly)
+		{
+		iFileFlag=MBackupObserver::EReleaseLockReadOnly;
+		}
+	else
+		{
+		iFileFlag=MBackupObserver::EReleaseLockNoAccess;
+		}
+	return CBackupDialogBase::OkToExitL(aButtonId);
+	}
+
+
+/**********************************************
+
+ 
+ 
+ 	CBackupRestartDialog
+ 
+ 
+ 
+************************************************/
+
+/**
+   Auxiliary function for TestCaseID tbackup-CmdRestartL
+  
+   This method initialises and launches the backup restart dialog.
+  
+ */
+TBool CBackupRestartDialog::RunDlgLD(CDesCArray& aFiles,CBackupDialogBase::TOperationGranularity& aGranularity,
+										TDes& aFileName)
+	{ // static
+	CBackupRestartDialog* dlg=new(ELeave) CBackupRestartDialog(aFiles,aGranularity,aFileName);
+	return dlg->ExecuteLD(R_TBACKUP_FILE_OPTIONS);
+	}
+
+CBackupRestartDialog::CBackupRestartDialog(CDesCArray& aFiles,CBackupDialogBase::TOperationGranularity& aGranularity,
+											TDes& aFileName)
+	: CBackupDialogBase(aFiles,aGranularity,aFileName)
+/**
+   Constructor
+ */
+	{}
+
+/**
+   Auxiliary function for TestCaseID tbackup-CmdRestartL
+  
+   This method is an override from CEikDialog.It performs pre-layout dialog
+   initialisation.
+  
+ */
+void CBackupRestartDialog::PreLayoutDynInitL()
+	{
+	SetTitleL(R_TBACKUP_RESTART_DLG_TITLE);
+	TBuf<20> text;
+	iCoeEnv->ReadResource(text,R_TBACKUP_RESTART_OPTION_TITLE);
+	CEikLabel* caption=Line(EDlgBackupCloseOpButList)->iCaption;
+	caption->SetTextL(text);
+	DeleteLine(EDlgBackupFlagOpButList);
+	CBackupDialogBase::PreLayoutDynInitL();
+	}
+
+
+
+/**********************************************
+ 
+ 
+ 
+ 	CBackupFileObserver
+ 
+ 
+ 
+************************************************/
+CBackupFileObserver::TBackupFile::TBackupFile(const TDesC& aFileName,TFileLock aLockState)
+	: iFileName(aFileName), iLockState(aLockState)
+/**
+   Constructor
+ */
+	{}
+
+/**
+   Auxiliary function for all test cases
+  
+   This method is part of two-phase construction of CBackupFileObserver.The
+   method is called by CTBackupAppUi::CreateFileObserversL() to construct new
+   client to backup server.
+  
+ */
+CBackupFileObserver* CBackupFileObserver::NewLC()
+	{ // static
+	CBackupFileObserver* self=new(ELeave) CBackupFileObserver();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+CBackupFileObserver::~CBackupFileObserver()
+/**
+   Destructor
+ */
+	{
+	const TInt count=iBackupArray.Count();
+	for (TInt ii=count-1;ii>=0;ii--)
+		{
+		const TBackupFile& backup=iBackupArray[ii];
+		RemoveFile(backup.iFileName);
+		}
+	iBackupArray.Close();
+	delete iBackupSession;
+	}
+
+struct SFileAddCleanup
+	{
+	CBackupFileObserver* iFileObserver;
+	TFileName iFileName;
+	};
+
+/**
+   Auxiliary function for all Test Cases
+   
+   This method is cleanup operation invoked by the pop and destroy action
+   resulting from a subsequent call to CleanupStack::PopAndDestroy() to
+   perform clean up of SFileAddCleanup object.
+   
+ */
+LOCAL_C void CleanupAddFile(TAny* aPtr)
+	{
+	SFileAddCleanup* cleanup=REINTERPRET_CAST(SFileAddCleanup*,aPtr);
+	cleanup->iFileObserver->RemoveFile(cleanup->iFileName);
+	}
+
+/**
+   Auxiliary function for all Test Cases
+   
+   This method registers a file with the backup server.
+   
+ */
+void CBackupFileObserver::AddFileL(const TDesC& aFileName)
+	{
+	TBackupFile backup(aFileName,ELocked);
+	User::LeaveIfError(iBackupArray.Append(backup));
+	SFileAddCleanup cleanup;
+	cleanup.iFileObserver=this;
+	cleanup.iFileName=aFileName;
+	CleanupStack::PushL(TCleanupItem(CleanupAddFile,&cleanup));
+	iBackupSession->RegisterFileL(aFileName,*this);
+	CleanupStack::Pop(); // CleanupAddFile
+	}
+
+/**
+   Auxiliary function for all Test Cases
+   
+   This method is invoked by cleanup method CleanupAddFile() to remove the
+   registration of a file with the backup server.
+   
+ */
+void CBackupFileObserver::RemoveFile(const TDesC& aFileName)
+	{
+	const TInt index=Find(aFileName);
+	if (index!=KErrNotFound)
+		{
+		iBackupSession->DeregisterFile(aFileName);
+		iBackupArray.Remove(index);
+		iBackupArray.Compress();
+		}
+	}
+
+/**
+   Auxiliary function for all Test Cases
+   
+   This method returns the array iBackupArray which holds the list of files
+   registered with the observer.
+   
+ */
+const RArray<CBackupFileObserver::TBackupFile>& CBackupFileObserver::BackupArray() const
+	{
+	return iBackupArray;
+	}
+
+CBackupFileObserver::CBackupFileObserver()
+/**
+   Constructor
+ */
+	{}
+
+/**
+   Auxiliary function for all test cases
+  
+   This method is part of Two-phase construction of CBackupFileObserver.The
+   method constructs a new client to the backup server .
+  
+ */
+void CBackupFileObserver::ConstructL()
+	{
+	iBackupSession=CBaBackupSessionWrapper::NewL();
+	}
+
+/**
+   Auxiliary function for all Test Cases
+   
+   This method attempts to find the file specifed within the iBackupArray
+   and returns its index within the array if found. Otherwise KErrNotFound is
+   returned.
+   
+ */
+TInt CBackupFileObserver::Find(const TDesC& aFileName) const
+	{
+	TInt index=KErrNotFound;
+	const TInt count=iBackupArray.Count();
+	for (TInt ii=0;ii<count;ii++)
+		{
+		const TBackupFile& backup=iBackupArray[ii];
+		if (backup.iFileName==aFileName)
+			{
+			index=ii;
+			break;
+			}
+		}
+	return index;
+	}
+
+/**
+   Auxiliary function for all Test Cases
+   
+   This method finds the file specifed within the iBackupArray and changes its
+   file lock as specified by aFlag parameter.
+   
+ */
+void CBackupFileObserver::ChangeFileLockL(const TDesC& aFileName,TFileLockFlags aFlags)
+	{
+	const TInt index=Find(aFileName);
+	if (index==KErrNotFound)
+		{
+		User::Invariant();
+		}
+	iBackupArray[index].iLockState=(CBackupFileObserver::TFileLock)aFlags;
+	}
+
+
+/**********************************************
+ 
+ 
+  	CBackupOpeartionObserver
+ 
+ 
+************************************************/
+
+/**
+   Auxiliary function for all Test cases
+   
+   This method returns ETrue if the observer is registered with the backup
+   server.
+  
+ */
+inline TBool CBackupOpeartionObserver::IsRegistered() const
+	{
+	return iRegistered;
+	}
+
+/**
+   Auxiliary function for TestCaseID tbackup-AutoUpdateBackupObserverRegistrationL
+  
+   The method sets the observer as registered with the back up server.
+  
+ */
+inline void CBackupOpeartionObserver::SetRegistered(TBool aIsRegistered)
+	{
+	iRegistered = aIsRegistered;
+	}
+
+/**
+   Auxiliary function for all Test cases
+   
+   This method creates an observer for backup operation.
+  
+ */
+CBackupOpeartionObserver* CBackupOpeartionObserver::NewL()
+	{
+	CBackupOpeartionObserver* self=new(ELeave) CBackupOpeartionObserver();
+	return self;
+	}
+
+CBackupOpeartionObserver::CBackupOpeartionObserver()
+/**
+   Constructor
+ */
+	{
+	}
+
+/**
+   Auxiliary function for TestCaseID tbackup-AutoUpdateBackupOperationStateL
+  
+   This method is an override from MBackupOperationObserver and is invoked when a
+   backup or restore operation either starts or ends.
+  
+ */
+void CBackupOpeartionObserver::HandleBackupOperationEventL(const TBackupOperationAttributes& aBackupOperationAttributes)
+	{
+	MBackupOperationObserver::TOperationType operation = aBackupOperationAttributes.iOperation;
+	switch (operation)
+		{
+		case MBackupOperationObserver::EStart:
+			User::InfoPrint(_L("Backup Operation Start"));
+			break;
+		case MBackupOperationObserver::EEnd:
+			User::InfoPrint(_L("Backup Operation End"));
+			break;
+		case MBackupOperationObserver::EAbort:
+			User::InfoPrint(_L("Backup Operation Abort"));
+			break;
+		case MBackupOperationObserver::ENone:
+		default:
+			break;
+		}
+	iBackupOperationAttributes = aBackupOperationAttributes;
+	}
+
+
+
+/**********************************************
+ 
+ 
+ 
+ 	CBackupOpeartionObserversWrapper
+ 
+ 
+ 
+************************************************/
+
+
+/**
+   Auxiliary function for TestCaseID tbackup-AutoUpdateBackupObserverRegistrationL
+  
+   This method returns the number of backup observer object pointers stored in
+   the pointer array iBackupOpeartionObserver.
+  
+ */
+inline TInt CBackupOpeartionObserversWrapper::CountObservers() const
+	{
+	return iBackupOpeartionObserver.Count();
+	}
+
+
+/**
+   Auxiliary function for TestCaseID tbackup-AutoUpdateBackupObserverRegistrationL
+  
+   This method returns the backup operation observer handle specified by
+   aIndex from pointer array iBackupOpeartionObserver.
+  
+ */
+inline CBackupOpeartionObserver* CBackupOpeartionObserversWrapper::Observer(TInt aIndex)
+	{
+	return iBackupOpeartionObserver[aIndex];
+	}
+
+
+/**
+   Auxiliary function for all Test Cases
+  
+   This method creates a wrapper for backup operation observers. The wrapper
+   would contains number of observers as indicated by parameter
+   aNumberOfObservers.
+  
+ */
+CBackupOpeartionObserversWrapper* CBackupOpeartionObserversWrapper::NewL(TInt aNumberOfObservers)
+	{
+	CBackupOpeartionObserversWrapper* self=new(ELeave) CBackupOpeartionObserversWrapper();
+	CleanupStack::PushL(self);
+	self->ConstructL(aNumberOfObservers);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CBackupOpeartionObserversWrapper::~CBackupOpeartionObserversWrapper()
+/**
+   Destructor
+ */
+	{
+	ResetAndDestroy();
+	iBackupOpeartionObserver.Close();
+	delete iBackupSession;
+	}
+
+CBackupOpeartionObserversWrapper::CBackupOpeartionObserversWrapper()
+/**
+   Constructor
+ */
+	{
+	}
+
+/**
+   Auxiliary function for all Test Cases
+  
+   This method creates 'aNumberOfObservers' of backup operation observers for
+   the wrapper.
+  
+ */
+void CBackupOpeartionObserversWrapper::ConstructL(TInt aNumberOfObservers)
+	{
+	iBackupSession=CBaBackupSessionWrapper::NewL();
+	for (TInt counter=0; counter<aNumberOfObservers; ++counter)
+		{
+		User::LeaveIfError(iBackupOpeartionObserver.Append(CBackupOpeartionObserver::NewL()));
+		}
+	}
+
+/**
+   Auxiliary function for TestCaseID tbackup-AutoUpdateBackupObserverRegistrationL
+  
+   The method registers the specified observer for notifications when a backup
+   operation starts or ends and sets the observer as registered by calling
+   CBackupOpeartionObserver::SetRegistered().
+  
+ */
+void CBackupOpeartionObserversWrapper::RegisterBackupOperationObserverL(CBackupOpeartionObserver& aBackupOpeartionObserver)
+	{
+	iBackupSession->RegisterBackupOperationObserverL(aBackupOpeartionObserver);
+	aBackupOpeartionObserver.SetRegistered(ETrue);
+	}
+
+/**
+   Auxiliary function for all Test Cases
+  
+   The method de-registers the specified backup/restore observer and resets the
+   iRegister flag of observer by calling
+   CBackupOpeartionObserver::SetRegistered(). The method is invoked by
+   CBackupOpeartionObserversWrapper::ResetAndDestroy() during destruction.
+  
+ */
+void CBackupOpeartionObserversWrapper::DeRegisterBackupOperationObserver(CBackupOpeartionObserver& aBackupOpeartionObserver)
+	{
+	iBackupSession->DeRegisterBackupOperationObserver(aBackupOpeartionObserver);
+	aBackupOpeartionObserver.SetRegistered(EFalse);
+	}
+
+/**
+   Auxiliary function for all Test Cases
+  
+   This method is invoked by destructor to deregister all backup observers
+   present in the wrapper. 
+  
+ */
+void CBackupOpeartionObserversWrapper::ResetAndDestroy()
+	{
+	const TInt count = iBackupOpeartionObserver.Count();
+	for (TInt index=0; index<count; ++index)
+		{
+		iBackupSession->DeRegisterBackupOperationObserver(*iBackupOpeartionObserver[index]);
+		}
+	iBackupOpeartionObserver.ResetAndDestroy();
+	iBackupOpeartionObserver.Close();
+	}
+
+/**********************************************
+ 
+ 
+ 
+ 	CBackupRegistrationDialog
+ 
+ 
+ 
+************************************************/
+
+CBackupRegistrationDialog::CBackupRegistrationDialog(RPointerArray<CBackupOpeartionObserversWrapper>& aBackupOperationObserversWrapper)
+	: iBackupOperationObserversWrapper(aBackupOperationObserversWrapper)
+/**
+   Constructor
+ */
+	{
+	}
+
+/**
+   Auxiliary Function tbackup-UpdateBackupObserverRegistrationL
+  
+   This method is an override from CEikDialog.It performs pre-layout dialog
+   initialisation. The method finds whether all observers for each observer
+   wrapper are registered and the state of each is displayed as a checkbox
+   on the dialog.
+  
+ */
+void CBackupRegistrationDialog::PreLayoutDynInitL()
+	{
+	const TInt count = iBackupOperationObserversWrapper.Count();
+	CBackupOpeartionObserversWrapper* observerWrapper = NULL;
+	TInt previousCount = 0;
+	for (TInt index1=0; index1<count; ++index1)
+		{
+		observerWrapper = iBackupOperationObserversWrapper[index1];
+		const TInt count2 = observerWrapper->CountObservers();
+		for (TInt index2=0; index2<count2; ++index2)
+			{
+			CBackupOpeartionObserver* observer = observerWrapper->Observer(index2);
+			const TInt realIndex = previousCount+index2;
+			CEikCheckBox* checkBox = (CEikCheckBox*)Control(EObserversId+realIndex);
+			checkBox->SetState(observer->IsRegistered() ? CEikButtonBase::ESet : CEikButtonBase::EClear);
+			}
+		previousCount += count2;
+		}
+	}
+
+/**
+   Auxiliary function for TestCaseID tbackup-UpdateBackupObserverRegistrationL
+  
+   This method is an override from CEikDialog. On click of OK button this
+   method checks whether the check boxes that represent observers in each
+   wrapper is set or reset and registers or deregisters the backup observer.
+  
+ */
+TBool CBackupRegistrationDialog::OkToExitL(TInt aButtonId)
+	{
+	if (aButtonId==EEikBidOk)
+		{
+		const TInt count = iBackupOperationObserversWrapper.Count();
+		CBackupOpeartionObserversWrapper* observerWrapper = NULL;
+		TInt previousCount = 0;
+		for (TInt index1=0; index1<count; ++index1)
+			{
+			observerWrapper = iBackupOperationObserversWrapper[index1];
+			const TInt count2 = observerWrapper->CountObservers();
+			for (TInt index2=0; index2<count2; ++index2)
+				{
+				CBackupOpeartionObserver* observer = observerWrapper->Observer(index2);
+				const TInt realIndex = previousCount+index2;
+				CEikCheckBox* checkBox = (CEikCheckBox*)Control(EObserversId+realIndex);
+				
+				const TBool stateSet = (checkBox->State()==CEikButtonBase::ESet);
+				const TBool previousState = observer->IsRegistered();
+				const TBool stateChanged = (!stateSet)!=(!previousState);
+				if (stateChanged)
+					{
+					if (stateSet)
+						{
+						observerWrapper->RegisterBackupOperationObserverL(*observer);
+						}
+					else
+						{
+						observerWrapper->DeRegisterBackupOperationObserver(*observer);
+						}
+					}
+				}
+			previousCount += count2;
+			}
+		}
+	return ETrue;
+	}
+
+
+/**********************************************
+ 
+ 
+ 
+ 	CBackupOperationDialog
+ 
+ 
+ 
+************************************************/
+CBackupOperationDialog::CBackupOperationDialog(CBaBackupSessionWrapper& aBackupSession)
+	:iBackupSession(aBackupSession)
+/**
+   Constructor
+ */
+	{}
+
+/**
+   Auxiliary function for TestCaseID tbackup-UpdateBackupOperationStateL
+  
+   This method is an override from CEikDialog.It performs pre-layout dialog
+   initialisation. The method invokes 
+   CBaBackupSessionWrapper::IsBackupOperationRunning() to find whether backup
+   operation is in running and accordingly sets 'Start' & 'End' option buttons.
+  
+ */
+void CBackupOperationDialog::PreLayoutDynInitL()
+	{
+	CEikHorOptionButtonList* optionButtonList = (CEikHorOptionButtonList*)Control(EDlgBackupOperationSel);
+	const TBool isRunning = iBackupSession.IsBackupOperationRunning();
+	optionButtonList->SetButtonById(isRunning ? EDlgBackupOperationSel1 : EDlgBackupOperationSel2);
+	}
+
+/**
+   Auxiliary function for TestCaseID tbackup-UpdateBackupOperationStateL
+  
+   This method is an override from CEikDialog. On click of OK button this
+   method checks the state of option buttons labeled 'Start' & 'End'
+   and accordingly starts / ends the backup operation by calling
+   CBaBackupSessionWrapper::NotifyBackupOperationL().
+  
+ */
+TBool CBackupOperationDialog::OkToExitL(TInt aButtonId)
+	{
+	if (aButtonId==EEikBidOk)
+		{
+		CEikHorOptionButtonList* optionButtonList = (CEikHorOptionButtonList*)Control(EDlgBackupOperationSel);
+		const TInt labeledButtonId = optionButtonList->LabeledButtonId();
+		TBackupOperationAttributes backupOperationAttributes;
+		switch (labeledButtonId)
+			{
+		case EDlgBackupOperationSel1:
+			{
+			backupOperationAttributes.iFileFlag = MBackupObserver::EReleaseLockReadOnly;
+			backupOperationAttributes.iOperation = MBackupOperationObserver::EStart;
+			break;
+			}
+		case EDlgBackupOperationSel2:
+			{
+			backupOperationAttributes.iFileFlag = MBackupObserver::ETakeLock;
+			backupOperationAttributes.iOperation = MBackupOperationObserver::EEnd;
+			break;
+			}
+		default:
+			return EFalse;
+			}
+		iBackupSession.NotifyBackupOperationL(backupOperationAttributes);
+		}
+	return ETrue;
+	}
+
+
+/**********************************************
+ 
+ 
+ 
+ 	CBackdrop
+ 
+ 
+ 
+************************************************/
+
+
+/**
+   Auxiliary function for all Test Cases
+  
+   This method is part of Two - phase construction. It creates the background
+   control.
+  
+ */
+CBackdrop* CBackdrop::NewL()
+	{ // static
+	CBackdrop* self=new(ELeave) CBackdrop();
+	CleanupStack::PushL(self);
+	self->CreateWindowL();
+	CleanupStack::Pop(); // self
+	return self;
+	}
+/**
+   Auxiliary function for all Test Cases
+  
+   This method is an override from CCoeControl. It draws the background
+   control.
+  
+ */
+void CBackdrop::Draw(const TRect& aRect) const
+	{
+	CWindowGc& gc=SystemGc();
+	gc.SetPenStyle(CGraphicsContext::ESolidPen);
+	gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+	gc.SetPenColor(KRgbGreen);
+	gc.SetBrushColor(KRgbGreen);
+	gc.DrawRect(aRect);
+	}
+
+
+/**********************************************
+ 
+ 
+ 
+ 	COpenAppList
+ 
+ 
+ 
+************************************************/
+
+/**
+   Auxiliary function for TestCaseID tbackup-CmdListAppsL
+  
+   This method creates a client session with the windows server and retrieves
+   the window group list currently available. The caption or the thread id for
+   each of window groups from the list is obtained and added to the list box.
+  
+ */
+void COpenAppList::UpdateL()
+	{
+	RWsSession& wsSession=iEikonEnv->WsSession();
+	TInt count=wsSession.NumWindowGroups(0);
+	if (!count)
+		return;
+	CDesCArray* tasks=new(ELeave) CDesCArrayFlat(count);
+	CleanupStack::PushL(tasks);
+	CArrayFixFlat<TInt>* wgIds=new(ELeave) CArrayFixFlat<TInt>(count);
+	CleanupStack::PushL(wgIds);
+	CApaWindowGroupName* wgName=CApaWindowGroupName::NewLC(wsSession);
+	wsSession.WindowGroupList(0,wgIds);
+	TBuf<2*KMaxFileName+1> name;
+	const TInt wgCount=wgIds->Count();
+	for (TInt ii=0;ii<wgCount;ii++)
+		{ 
+		const TInt wgId=(*wgIds)[ii];
+		wgName->ConstructFromWgIdL(wgId);
+		TPtrC caption=wgName->Caption();
+		if(wgName->Hidden())
+			{
+			continue;
+			}
+		else if (caption.Length()==0) // not set yet - use thread name instead
+			{
+			TThreadId threadId;
+			TInt err=wsSession.GetWindowGroupClientThreadId(wgId,threadId);
+			if (err==KErrNone)
+				{
+				RThread thread;
+				err=thread.Open(threadId);
+				if (err==KErrNone)
+					{
+					name.Copy(thread.Name());
+					thread.Close();
+					}
+				}
+			if (err!=KErrNone)
+				name.Copy(_L("???"));
+			}
+		else
+			{
+			name=caption;
+			name.Append(' ');
+			TFileName docName=wgName->DocName();
+			name.Append(docName);
+			}
+		tasks->AppendL(name);
+		}
+	CleanupStack::PopAndDestroy(2); // wgIds, wgName
+	Model()->SetItemTextArray(tasks);
+	CleanupStack::Pop(); // tasks
+	HandleItemAdditionL();
+	}
+
+/**********************************************
+ 
+  
+ 	COpenFileList
+ 
+ 
+ 
+************************************************/
+
+COpenFileList::COpenFileList(CArrayPtr<CBackupFileObserver>& aFileObservers)
+	: iFileObservers(aFileObservers)
+/**
+   Constructor
+ */
+	{}
+
+COpenFileList::~COpenFileList()
+/**
+   Destructor
+ */
+	{
+	delete iList;
+	}
+
+/**
+   Auxiliary function for all Test Cases
+  
+   The method creates a Column List Box and sets the width for all the
+   columns in the list box.
+  
+ */
+void COpenFileList::ConstructL()
+	{
+	CreateWindowL();
+	iList=new(ELeave) CEikColumnListBox();
+	iList->ConstructL(this);
+	CColumnListBoxData* columnData=iList->ItemDrawer()->ColumnData();
+	// following assumes a know width for this control
+	// bad practise but not worth writing a scalable control in this test app
+	columnData->SetColumnWidthPixelL(0,20);
+	columnData->SetColumnWidthPixelL(1,180);
+	columnData->SetColumnWidthPixelL(2,100);
+	}
+
+/**
+   Auxiliary function for TestCaseID tbackup_CmdListOpenFilesL
+  
+   This method lists filename and lock state of all files associated with the
+   file observers.
+  
+ */
+void COpenFileList::UpdateL()
+	{
+	CDesCArray* textArray=new(ELeave) CDesCArrayFlat(2);
+	CleanupStack::PushL(textArray);
+	TChar separator(KColumnListSeparator);
+	const TInt obsCount=iFileObservers.Count();
+	for (TInt ii=0;ii<obsCount;ii++)
+		{
+		TBuf<2> num;
+		num.Num(ii);
+		const RArray<CBackupFileObserver::TBackupFile>& backupArray=iFileObservers[ii]->BackupArray();
+		const TInt fileCount=backupArray.Count();
+		for (TInt jj=0;jj<fileCount;jj++)
+			{
+			TBuf<300> buf;
+			buf.Append(num);
+			const CBackupFileObserver::TBackupFile& backupFile=backupArray[jj];
+			buf.Append(separator);
+			buf.Append(backupFile.iFileName);
+			buf.Append(separator);
+			TBuf<20> lockState;
+			if (backupFile.iLockState==CBackupFileObserver::ELocked)
+				{
+				iCoeEnv->ReadResource(lockState,R_TBACKUP_LOCKSTATE_LOCKED);
+				}
+			else if (backupFile.iLockState==CBackupFileObserver::EReadOnly)
+				{
+				iCoeEnv->ReadResource(lockState,R_TBACKUP_LOCKSTATE_READONLY);
+				}
+			else if(backupFile.iLockState==CBackupFileObserver::ENoAccess)
+				{
+				iCoeEnv->ReadResource(lockState,R_TBACKUP_LOCKSTATE_NOACCESS);
+				}
+			else
+				{
+				lockState=_L("???");
+				}
+			buf.Append(lockState);
+			textArray->AppendL(buf);
+			}
+		}
+	iList->Model()->SetItemTextArray(textArray);
+	CleanupStack::Pop(); // textArray
+	iList->HandleItemAdditionL();
+	}
+
+/**
+   Auxiliary function for all Test Cases
+  
+   The method is an override from CCoeControl. It returns minimum required
+   size of column list box.
+  
+ */
+TSize COpenFileList::MinimumSize()
+	{
+	return iList->MinimumSize();
+	}
+
+/**
+   Auxiliary function for all Test Cases
+  
+   The method is an override from CCoeControl. It is invoked to set the size
+   and position of the content of list box control.
+  
+ */
+void COpenFileList::SizeChanged()
+	{
+	const TRect rect(Rect());
+	iList->SetRect(rect);
+	}
+
+/**
+   Auxiliary function for all Test Cases
+  
+   The method is an override from CCoeControl. It returns the number of
+   controls contained in the compound control COpenFileList.
+  
+ */
+TInt COpenFileList::CountComponentControls() const
+	{
+	return 1;
+	}
+
+/**
+   Auxiliary function for all Test Cases
+  
+   The method is an override from CCoeControl. It returns the handle to list
+   box present on compound control COpenFileList.  
+  
+ */
+CCoeControl* COpenFileList::ComponentControl(TInt aIndex) const
+	{
+	if (aIndex==0)
+		{
+		return iList;
+		}
+	return NULL;
+	}
+
+
+/**********************************************
+ 
+ 
+ 
+ 	CTBackupAppUi
+ 
+ 
+ 
+************************************************/
+
+CTBackupAppUi::CTBackupAppUi(CTmsTestStep* aStep) :
+	CTestAppUi(aStep, KTBackupResourceFilePath)//,		R_TBACKUP_HOTKEYS, R_TBACKUP_MENUBAR, R_TBACKUP_TOOLBAR)
+/**
+   Constructor
+ */
+	{
+	}
+/**
+   Auxiliary function for all Test Cases
+   
+   This method creates a client interface to the backup server and performs the
+   following:
+   (a) Creates a background control.
+   (b) Creates backup observers and adds files to the observer.
+   (c) Creates an Application List from window groups.
+   (d) Creates a list for files attached to the observers.
+   
+ */
+void CTBackupAppUi::ConstructL()
+	{
+	CTestAppUi::ConstructL();
+	iEikonEnv->SetSystem(ETrue);
+	iBackupSession=CBaBackupSessionWrapper::NewL();
+
+	CreateBackgroundL();
+	CreateFileObserversL();
+	CreateAppListL();
+	CreateFileListL();
+	CreateObserversListL();
+	iBusyMsg = new (ELeave) CEikBusyMsgWin(*iEikonEnv);
+	iBusyMsg->ConstructL(iEikonEnv->RootWin());
+	CTestAppUi::AutoTestManager().StartAutoTest();
+	}
+
+CTBackupAppUi::~CTBackupAppUi()
+/**
+   Destructor
+ */
+	{
+	delete iBackdrop;
+	delete iAppList;
+	delete iFileList;
+	if (iFileObservers)
+		{
+		iFileObservers->ResetAndDestroy();
+		delete iFileObservers;
+		}
+	iBackupOperationObserversWrapper.ResetAndDestroy();
+	iBackupOperationObserversWrapper.Close();
+	iBusyMsg->CancelDisplay();
+	delete iBusyMsg;
+	delete iBackupSession;
+	}
+
+/**
+   Auxiliary function for all Test Cases
+  
+   The method is an override from CTestAppUi. The method initiates back up
+   tests.
+   
+ */
+void CTBackupAppUi::RunTestStepL(TInt aNextStep)
+	{
+
+	switch(aNextStep)
+		{
+	case 1:
+		INFO_PRINTF1(_L("Test: List Apps."));
+		SetTestStepID(_L("UIF-tbackup-CmdListAppsL"));
+		HandleCommandL(EBackupCmdListApps);
+		RecordTestResultL();
+		INFO_PRINTF1(_L("List Apps Completed"));
+		break;
+	case 2:
+		INFO_PRINTF1(_L("Test: List Open Files."));
+		SetTestStepID(_L("UIF-tbackup-CmdListOpenFilesL"));
+		HandleCommandL(EBackupCmdListOpenFiles);
+		RecordTestResultL();
+		INFO_PRINTF1(_L("List Open Files Completed"));
+		break;
+	case 3:
+		INFO_PRINTF1(_L("Test: Close Files."));
+		SetTestStepID(_L("UIF-tbackup-AutoCmdCloseL"));
+		HandleCommandL(EBackupCmdClose);
+		RecordTestResultL();
+		INFO_PRINTF1(_L("Close Files Completed"));
+		break;
+	case 4:
+		INFO_PRINTF1(_L("Test: Restart."));
+		SetTestStepID(_L("UIF-tbackup-AutoCmdRestartL"));
+		HandleCommandL(EBackupCmdRestart);
+		RecordTestResultL();
+		INFO_PRINTF1(_L("Restart Completed"));
+		break;
+	case 5:
+		INFO_PRINTF1(_L("Test: CloseAllAndRestartAll."));
+		SetTestStepID(_L("UIF-tbackup-AutoCmdCloseAllAndRestartAllL"));
+		HandleCommandL(EBackupCmdCloseAllAndRestartAll);
+		RecordTestResultL();
+		INFO_PRINTF1(_L("CloseAllAndRestartAll Completed"));
+		break;
+	case 6:
+		INFO_PRINTF1(_L("Test: Register Objects."));
+		SetTestStepID(_L("UIF-tbackup-AutoUpdateBackupObserverRegistrationL"));
+		HandleCommandL(EBackupCmdRegisterObs);
+		RecordTestResultL();
+		INFO_PRINTF1(_L("Register Objects Completed."));
+
+		INFO_PRINTF1(_L("Test: Backup Operation."));
+		SetTestStepID(_L("UIF-tbackup-AutoUpdateBackupOperationStateL"));
+		HandleCommandL(EBackupCmdBackupOperation);
+		RecordTestResultL();
+		CloseTMSGraphicsStep();
+		INFO_PRINTF1(_L("Completed: Backup Operation running..."));
+		User::After(TTimeIntervalMicroSeconds32(2000000));
+		break;
+	case 7:
+		INFO_PRINTF1(_L("Test: Backup operation stop."));
+		HandleCommandL(EBackupCmdDestroyBackupOperationClient);
+		INFO_PRINTF1(_L("Backup operation stop completed"));
+		break;
+	case 8:
+		INFO_PRINTF1(_L("Tests completed - End of Test."));
+		CTestAppUi::AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass);
+		break;
+	default:
+		break;
+		}
+	}
+
+/**
+   Auxiliary function for all Test Cases
+  
+   This method is called by CTBackupAppUi::RunTestStepL() to initiate the
+   tests.
+   
+ */
+void CTBackupAppUi::HandleCommandL(TInt aCommand)
+	{
+	switch (aCommand)
+		{
+	case EEikCmdExit:
+		Exit();
+		break;
+	case EBackupCmdListApps:
+		CmdListAppsL();
+		break;
+	case EBackupCmdListOpenFiles:
+		CmdListOpenFilesL();
+		break;
+	case EBackupCmdClose:
+		AutoCmdCloseL();
+		break;
+	case EBackupCmdRestart:
+		AutoCmdRestartL();
+		break;
+	case EBackupCmdCloseAllAndRestartAll:
+		AutoCmdCloseAllAndRestartAllL();
+		break;
+	case EBackupCmdRegisterObs:
+		AutoUpdateBackupObserverRegistrationL();
+		break;
+	case EBackupCmdBackupOperation:
+		AutoUpdateBackupOperationStateL();
+		break;
+	case EBackupCmdDestroyBackupOperationClient:
+		{
+			const TBool backupOperationRunning = iBackupSession->IsBackupOperationRunning();
+	
+			if (backupOperationRunning)
+			{
+			iBusyMsg->CancelDisplay();
+			}
+
+			delete iBackupSession;
+			iBackupSession = NULL;
+		}
+		break;
+	default:
+		User::Leave(KErrNotSupported);
+		break;
+		}
+	}
+
+/**
+   Auxiliary function for all Test Cases
+   
+   This method creates the background control.
+   
+ */
+void CTBackupAppUi::CreateBackgroundL()
+	{
+	iBackdrop=CBackdrop::NewL();
+	const TRect clientRect=ClientRect();
+	iBackdrop->SetRect(clientRect);
+	iBackdrop->ActivateL();
+	}
+
+/**
+   Auxiliary function for all Test Cases
+   
+   This method creates a List Box and adds the list of applications currently
+   running.
+   
+ */
+void CTBackupAppUi::CreateAppListL()
+	{
+	iAppList=new(ELeave) COpenAppList();
+	iAppList->ConstructL(NULL,0);
+	TRect rect=ClientRect();
+	rect.Shrink(TSize(20,20));
+	iAppList->SetExtent(rect.iTl,rect.Size());
+	iAppList->UpdateL();
+	iAppList->ActivateL();
+	}
+
+/**
+   Auxiliary function for all Test Cases
+   
+   This method prepares a list of files associated with each of the observers
+   and adds them to a List Box.
+   
+ */
+void CTBackupAppUi::CreateFileListL()
+	{
+	iFileList=new(ELeave) COpenFileList(*iFileObservers);
+	iFileList->ConstructL();
+	TRect rect=ClientRect();
+	rect.Shrink(TSize(20,20));
+	iFileList->SetExtent(rect.iTl,rect.Size());
+	iFileList->UpdateL();
+	iFileList->ActivateL();
+	iFileList->MakeVisible(EFalse);
+	}
+
+/**
+   Auxiliary function for all Test Cases
+   
+   This method creates 3 file observers to the backup server and associates
+   them with their respective files.
+   
+ */
+void CTBackupAppUi::CreateFileObserversL()
+	{
+	iFileObservers=new(ELeave) CArrayPtrFlat<CBackupFileObserver>(3);
+	for (TInt ii=0;ii<3;ii++)
+		{
+		iFileObservers->AppendL(CBackupFileObserver::NewLC());
+		CleanupStack::Pop(); // CBackupFileObserver
+		}
+	CBackupFileObserver* backup=(*iFileObservers)[0];
+	backup->AddFileL(KBackupFile1);
+	backup->AddFileL(KBackupFile2);
+	backup->AddFileL(KBackupFile3);
+	backup=(*iFileObservers)[1];
+	backup->AddFileL(KBackupFile1);
+	backup->AddFileL(KBackupFile3);
+	backup=(*iFileObservers)[2];
+	backup->AddFileL(KBackupFile3);
+	}
+
+/**
+   Auxiliary function for all Test Cases
+   
+   This method creates observers for the backup operation.
+   
+ */
+void CTBackupAppUi::CreateObserversListL()
+	{
+	for (TInt ii=0; ii<KNumOfBackupOperationObservers; ++ii)
+		{
+		User::LeaveIfError(iBackupOperationObserversWrapper.Append(CBackupOpeartionObserversWrapper::NewL(ii+1)));
+		}
+	}
+
+/**
+   @SYMTestCaseID UIF-tbackup-CmdListAppsL
+  
+   @SYMPREQ
+  
+   @SYMTestCaseDesc Test retrieving the application list.
+  
+   @SYMTestPriority High
+  
+   @SYMTestStatus Implemented
+   
+   @SYMTestActions The method calls COpenAppList::UpdateL() to update the list of
+   applications currently running and makes the application list visible on the
+   background control.
+  
+   @SYMTestExpectedResults All currently running application should be listed.
+   
+ */
+void CTBackupAppUi::CmdListAppsL()
+	{
+	iAppList->UpdateL();
+	if (!iAppList->IsVisible())
+		{
+		iFileList->MakeVisible(EFalse);
+		iAppList->MakeVisible(ETrue);
+		}
+	iAppList->DrawNow();
+	}
+
+/**
+   @SYMTestCaseID UIF-tbackup-CmdListOpenFilesL
+  
+   @SYMPREQ
+  
+   @SYMTestCaseDesc Test retrieving the list of files associated with the file
+   observers.
+  
+   @SYMTestPriority High
+  
+   @SYMTestStatus Implemented
+   
+   @SYMTestActions The method calls COpenAppList::UpdateL() to update the list of
+   files associated with each file observer and makes the file list visible
+   on the background control. The access rights to these files are also displayed.
+  
+   @SYMTestExpectedResults All files associated with file observers should be listed.
+   
+ */
+void CTBackupAppUi::CmdListOpenFilesL()
+	{
+	iFileList->UpdateL();
+	if (!iFileList->IsVisible())
+		{
+		iAppList->MakeVisible(EFalse);
+		iFileList->MakeVisible(ETrue);
+		}
+	iFileList->DrawNow();
+	}
+
+/**
+   @SYMTestCaseID UIF-tbackup-CmdCloseL
+  
+   @SYMPREQ
+  
+   @SYMTestCaseDesc Test CloseFileL() & CloseAll() API's.
+  
+   @SYMTestPriority High
+  
+   @SYMTestStatus Implemented
+   
+   @SYMTestActions The method opens the close dialog.The user selection of 'All'
+   or 'Single File' is recognised and CBaBackupSessionWrapper::CloseAll() or
+   CBaBackupSessionWrapper::CloseFileL() is invoked to stop writing to a
+   specified file or all files respectively.
+  
+   @SYMTestExpectedResults The test checks whether the status of the asynchronous
+   request is KErrInUse.
+   
+ */
+void CTBackupAppUi::CmdCloseL()
+	{
+	CDesCArray* files=new(ELeave) CDesCArrayFlat(3);
+	CleanupStack::PushL(files);
+	files->AppendL(KBackupFile1);
+	files->AppendL(KBackupFile2);
+	files->AppendL(KBackupFile3);
+	CBackupDialogBase::TOperationGranularity granularity;
+	TFileName fileName;
+	MBackupObserver::TFileLockFlags fileFlag;
+	
+	if (CBackupCloseDialog::RunDlgLD(*files,granularity,fileName,fileFlag))
+		{
+		if (granularity==CBackupDialogBase::EAll)
+			{
+			TRequestStatus status=KRequestPending;
+			iBackupSession->CloseAll(fileFlag,status);
+			User::WaitForRequest(status);
+			}
+		else
+			{
+			iBackupSession->CloseFileL(fileName,fileFlag);
+			}
+		}
+	CleanupStack::PopAndDestroy(); // files
+	}
+
+/**
+   @SYMTestCaseID UIF-tbackup-AutoCmdCloseL
+  
+   @SYMPREQ
+  
+   @SYMTestCaseDesc Test CloseFileL() & CloseAll() API's.
+ 
+   @SYMTestPriority High
+  
+   @SYMTestStatus Implemented
+   
+   @SYMTestActions The method tests informing observers to stop writing to a specified
+   file by calling CBaBackupSessionWrapper::CloseFileL(). It also tests whether
+   CBaBackupSessionWrapper::CloseAll() closes all non-system applications and
+   calls all observers to stop writing to the registered files.
+  
+   @SYMTestExpectedResults The test checks whether the status of the asynchronous
+   request is KErrInUse.
+   
+ */
+void CTBackupAppUi::AutoCmdCloseL()
+	{
+	TFileName fileName;
+	MBackupObserver::TFileLockFlags fileFlag;
+	
+	fileFlag=MBackupObserver::EReleaseLockReadOnly;
+	fileName = KBackupFile1;
+	iBackupSession->CloseFileL(fileName,fileFlag);
+
+	TRequestStatus status=KRequestPending;
+
+	fileFlag=MBackupObserver::EReleaseLockReadOnly;
+	iBackupSession->CloseAll(fileFlag,status);
+	User::WaitForRequest(status);
+	
+	iBackupSession->RestartAll();
+	fileFlag=MBackupObserver::EReleaseLockNoAccess;
+	iBackupSession->CloseAll(fileFlag,status);
+	User::WaitForRequest(status);
+	}
+
+/**
+   @SYMTestCaseID UIF-tbackup-CmdRestartL
+  
+   @SYMPREQ
+  
+   @SYMTestCaseDesc Test RestartFileL() & RestartAll() APIs.
+  
+   @SYMTestPriority High
+  
+   @SYMTestStatus Implemented
+   
+   @SYMTestActions The method opens the backup restart dialog.The user selection
+   of 'All' or 'Single File' is recognised and
+   CBaBackupSessionWrapper::RestartAll() or
+   CBaBackupSessionWrapper::RestartFileL() is invoked to take back all file
+   locks on a specified file or on all files respectively.
+  
+   @SYMTestExpectedResults The checks whether the API CBaBackupSessionWrapper::RestartAll()
+   reverses a CBaBackupSessionWrapper::CloseAll() call.
+   
+ */
+void CTBackupAppUi::CmdRestartL()
+	{
+	CDesCArray* files=new(ELeave) CDesCArrayFlat(3);
+	CleanupStack::PushL(files);
+	files->AppendL(KBackupFile1);
+	files->AppendL(KBackupFile2);
+	files->AppendL(KBackupFile3);
+	CBackupDialogBase::TOperationGranularity granularity;
+	TFileName fileName;
+	
+	if (CBackupRestartDialog::RunDlgLD(*files,granularity,fileName))
+		{
+		if (granularity==CBackupDialogBase::EAll)
+			{
+			iBackupSession->RestartAll();
+			}
+		else
+			{
+			iBackupSession->RestartFile(fileName);
+			}
+		}
+	CleanupStack::PopAndDestroy(); // files
+	}
+
+/**
+   @SYMTestCaseID UIF-tbackup-AutoCmdRestartL
+  
+   @SYMPREQ
+  
+   @SYMTestCaseDesc Test RestartFileL() & RestartAll() APIs.
+  
+   @SYMTestPriority High
+  
+   @SYMTestStatus Implemented
+   
+   @SYMTestActions The method tests informing all observers to take back the file
+   lock for the specified file by calling CBaBackupSessionWrapper::RestartFile().
+   Similarly it also tests informing all observers to take back file locks for
+   the registered files by calling CBaBackupSessionWrapper::RestartAll()
+  
+   @SYMTestExpectedResults The method checks whether the API
+   CBaBackupSessionWrapper::RestartAll() reverses a
+   CBaBackupSessionWrapper::CloseAll() call.
+   
+ */
+void CTBackupAppUi::AutoCmdRestartL()
+	{
+	CDesCArray* files=new(ELeave) CDesCArrayFlat(3);
+	CleanupStack::PushL(files);
+	files->AppendL(KBackupFile1);
+	files->AppendL(KBackupFile2);
+	files->AppendL(KBackupFile3);
+	TFileName fileName;
+	
+	fileName = KBackupFile1;
+	iBackupSession->RestartFile(fileName);
+		
+	iBackupSession->RestartAll();
+
+	CleanupStack::PopAndDestroy(); // files
+	}
+
+/**
+   @SYMTestCaseID UIF-tbackup-AutoCmdCloseAllAndRestartAllL
+  
+   @SYMDEF DEF64721
+  
+   @SYMTestCaseDesc Test CloseAll() & RestartAll() APIs.
+  
+   @SYMTestPriority High
+  
+   @SYMTestStatus Implemented
+   
+   @SYMTestActions The method tests whether CBaBackupSessionWrapper::CloseAll() closes all 
+   non-system applications and calls all observers to stop writing to the registered files.
+   Similarly it also tests informing all observers to take back file locks for
+   the registered files by calling CBaBackupSessionWrapper::RestartAll()
+  
+   @SYMTestExpectedResults The method checks whether the API
+   CBaBackupSessionWrapper::RestartAll() reverses a
+   CBaBackupSessionWrapper::CloseAll() call.
+   
+ */
+void CTBackupAppUi::AutoCmdCloseAllAndRestartAllL()
+	{
+	RApaLsSession apaLsSession;
+	apaLsSession.Connect();
+
+	CApaCommandLine* cmdLn=CApaCommandLine::NewLC();
+	
+	_LIT(KLitExePath,"agenda.exe");
+	cmdLn->SetExecutableNameL(KLitExePath);
+	
+	TThreadId tId;
+	TRequestStatus appStatus= KRequestPending;
+
+	//Starting the application
+	TInt ret = apaLsSession.StartApp(*cmdLn,tId,&appStatus); // explicit
+  	INFO_PRINTF2(_L("StartApp return code is %d"), ret);
+	TEST(ret==KErrNone);
+	User::WaitForRequest(appStatus);
+
+	CleanupStack::PopAndDestroy(cmdLn);
+	
+	//Check whether the application is Started
+	TFullName repName; 
+	_LIT(KAppName,"agenda*");
+	{//(Scoped in order to reuse appThread)
+		TFindThread appThread(KAppName);
+		//TFindThread::Next gets the next thread that matches the pattern above
+		TEST(appThread.Next(repName) == KErrNone);
+	}
+	
+	RThread thread;
+	thread.Open(tId);
+
+	MBackupObserver::TFileLockFlags fileFlag;
+	fileFlag=MBackupObserver::EReleaseLockReadOnly;
+	TRequestStatus closeallStatus = KRequestPending;
+	
+	//Closing all the non system applications
+	iBackupSession->CloseAll(fileFlag,closeallStatus);
+	//Wait till all the applications are closed
+	User::WaitForRequest(closeallStatus);
+	
+	//Check whether the agenda application is closed in CloseAll
+	TEST(thread.ExitType() != EExitPending);
+		
+	//Restarting All the nonsystem applications which are closed by previous CloseAll Call
+	iBackupSession->RestartAll();
+	
+	//Check whether the application is Restarted
+	TFindThread appThread(KAppName);
+	TEST(appThread.Next(repName) == KErrNone);
+
+	apaLsSession.Close();
+	}
+		
+/**
+   @SYMTestCaseID UIF-tbackup-UpdateBackupObserverRegistrationL
+  
+   @SYMPREQ
+  
+   @SYMTestCaseDesc Tests registering observers for back up operation.
+  
+   @SYMTestPriority High
+  
+   @SYMTestStatus Implemented 
+   
+   @SYMTestActions The method creates a backup registration dialog and adds check
+   boxes to represent all observers that are associated to each of the
+   wrappers. On click of OK button of the dialog all selected observers should
+   be registered with the backup server.
+  
+   @SYMTestExpectedResults The method should register all observers for backup
+   operation.
+   
+ */
+void CTBackupAppUi::UpdateBackupObserverRegistrationL()
+	{
+	CBackupRegistrationDialog* dialog = new(ELeave) CBackupRegistrationDialog(iBackupOperationObserversWrapper);
+	dialog->ConstructAutoDialogLC(EEikDialogFlagWait, R_EIK_BUTTONS_CANCEL_OK);
+	dialog->SetTitleL(KRegistrationDlgTitle);
+	const TInt count = iBackupOperationObserversWrapper.Count();
+	TBuf<20> buf;
+	CBackupOpeartionObserversWrapper* observerWrapper = NULL;
+	TInt previousCount = 0;
+	for (TInt index1=0; index1<count; ++index1)
+		{
+		observerWrapper = iBackupOperationObserversWrapper[index1];
+		const TInt count2 = observerWrapper->CountObservers();
+		for (TInt index2=0; index2<count2; ++index2)
+			{
+			const TInt realIndex = previousCount+index2;
+			buf.Format(KObserverStr, realIndex+1);
+			CEikCheckBox* checkBox=(CEikCheckBox*)dialog->CreateLineByTypeL(buf, EObserversId+realIndex, EEikCtCheckBox, NULL);
+			checkBox->SetSize(checkBox->MinimumSize());
+			}
+		previousCount += count2;
+		}
+	dialog->RunLD();
+	}
+
+/**
+   @SYMTestCaseID UIF-tbackup-AutoUpdateBackupObserverRegistrationL
+  
+   @SYMPREQ
+  
+   @SYMTestCaseDesc Tests registering observers for back up operation.
+  
+   @SYMTestPriority High
+  
+   @SYMTestStatus Implemented 
+   
+   @SYMTestActions The method finds the number of the observers that each interface
+   object CBackupOpeartionObserversWrapper has and registers each of its observers
+   to receive notification for backup operation by calling
+   CBackupOpeartionObserversWrapper::RegisterBackupOperationObserverL().
+  
+   @SYMTestExpectedResults The method should register all observers for backup
+   operation.
+   
+ */
+void CTBackupAppUi::AutoUpdateBackupObserverRegistrationL()
+	{
+	//Following is copied from dialog->RunLD()....
+	const TInt count1 = iBackupOperationObserversWrapper.Count();
+	CBackupOpeartionObserversWrapper* observerWrapper = NULL;
+	TInt previousCount = 0;
+	for (TInt index3=0; index3<count1; ++index3)
+		{
+		observerWrapper = iBackupOperationObserversWrapper[index3];
+		const TInt count2 = observerWrapper->CountObservers();
+		for (TInt index4=0; index4<count2; ++index4)
+			{
+			CBackupOpeartionObserver* observer = observerWrapper->Observer(index4);
+			observerWrapper->RegisterBackupOperationObserverL(*observer);
+			}
+			previousCount += count2;
+		}
+	}		
+		
+/**
+   @SYMTestCaseID UIF-tbackup-UpdateBackupOperationStateL
+  
+   @SYMPREQ
+  
+   @SYMTestCaseDesc Manual Test to start / end back up operation.
+  
+   @SYMTestPriority High
+  
+   @SYMTestStatus Implemented
+   
+   @SYMTestActions The method displays the backup operation dialog with option
+   buttons labelled 'Start' or 'End'. On click of OK button the state of
+   option buttons is verified and backup operation is started or ended.
+  
+   @SYMTestExpectedResults The method CBaBackupSessionWrapper::IsBackupOperationRunning()
+   is invoked to verify the start of backup operation.
+   
+ */
+void CTBackupAppUi::UpdateBackupOperationStateL()
+	{
+	CEikDialog* dialog = new(ELeave) CBackupOperationDialog(*iBackupSession);
+	dialog->ExecuteLD(R_TBACKUP_BACKUP_OPERATION);
+	const TBool backupOperationRunning = iBackupSession->IsBackupOperationRunning();
+	if (backupOperationRunning)
+		{
+		iBusyMsg->StartDisplay(KBackupOpMsg, TGulAlignment(EHLeftVTop));
+		}
+	else
+		{
+		iBusyMsg->CancelDisplay();
+		}
+	}
+
+/**
+   @SYMTestCaseID UIF-tbackup-AutoUpdateBackupOperationStateL
+  
+   @SYMPREQ
+  
+   @SYMTestCaseDesc Test starting of back up operation.
+  
+   @SYMTestPriority High
+  
+   @SYMTestStatus Implemented
+   
+   @SYMTestActions The method prepares the attributes to start the backup operation
+   and notifies the server to start a backup operation by calling
+   CBaBackupSessionWrapper::NotifyBackupOperationL(). The method then checks
+   whether the backup operation has started by calling
+   CBaBackupSessionWrapper::IsBackupOperationRunning(). Note that on start of
+   backup operation CBackupOpeartionObserver::HandleBackupOperationEventL() is
+   invoked by the server to notify client of backup start oiperation.
+  
+   @SYMTestExpectedResults The method CBaBackupSessionWrapper::IsBackupOperationRunning()
+   should return ETrue to indicate the start of backup operation.
+   
+ */
+void CTBackupAppUi::AutoUpdateBackupOperationStateL()
+	{
+
+	//From dialog OKToExit
+
+	const TInt labeledButtonId = EDlgBackupOperationSel1;
+	
+	//Another test case is required.
+	//labeledButtonId = EDlgBackupOperationSel2;
+
+	TBackupOperationAttributes backupOperationAttributes;
+	switch (labeledButtonId)
+		{
+		case EDlgBackupOperationSel1:
+			{
+			backupOperationAttributes.iFileFlag = MBackupObserver::EReleaseLockReadOnly;
+			backupOperationAttributes.iOperation = MBackupOperationObserver::EStart;
+			break;
+			}
+		case EDlgBackupOperationSel2:
+			{
+			backupOperationAttributes.iFileFlag = MBackupObserver::ETakeLock;
+			backupOperationAttributes.iOperation = MBackupOperationObserver::EEnd;
+			break;
+			}
+		default:
+			//return EFalse;
+			break;
+		}
+	
+	iBackupSession->NotifyBackupOperationL(backupOperationAttributes);
+
+	// Run backup operation. This continues to run until the cancel backup command is
+	// chosen.
+	const TBool backupOperationRunning = iBackupSession->IsBackupOperationRunning();
+	
+	if (backupOperationRunning)
+		{
+		iBusyMsg->StartDisplay(KBackupOpMsg, TGulAlignment(EHLeftVTop));
+		}
+	else
+		{
+		iBusyMsg->CancelDisplay();
+		}
+	}
+
+/**********************************************
+ 
+ 
+ 
+ 	CTestBackupStep
+ 
+ 
+ 
+************************************************/
+CTestBackupStep::CTestBackupStep()
+/**
+   Constructor
+ */
+	{
+	SetTestStepName(KTestBackupStep);
+	}
+
+CTestBackupStep::~CTestBackupStep()
+/**
+   Destructor
+ */
+	{
+	}
+
+/**
+   Auxiliary function for all Test Cases
+  
+   The method creates & sets the application's user interface object.
+   
+ */
+void CTestBackupStep::ConstructAppL(CEikonEnv* aCoe)
+    { // runs inside a TRAP harness
+	aCoe->ConstructL();
+
+	CTestAppUi* appUi= new (ELeave) CTBackupAppUi(this);
+    aCoe->SetAppUi(appUi);
+    appUi->ConstructL();
+    }
+
+/**
+   Auxiliary function for all Test Cases
+  
+   The method creates & sets the test step's user interface object and
+   launches the test step.
+   
+ */
+TVerdict CTestBackupStep::doTestStepL() // main function called by E32
+	{
+	PreallocateHALBuffer();
+	__UHEAP_MARK;
+
+	CEikonEnv* coe=new CEikonEnv;
+	TRAPD(err,ConstructAppL(coe));
+
+	if (!err)
+		coe->ExecuteD();
+
+	REComSession::FinalClose();	
+	__UHEAP_MARKEND;
+
+	return TestStepResult();
+	}
+
+