// Copyright (c) 2004-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:
//

/**
 @file
 @released
*/

#include <connect/sbtypes.h>
#include "t_teststepbackup2.h"
#include <apgcli.h>
#include <connect/javamanagerinterface.h>

namespace bur_ts
	{	
		
	CBURTestStepBackup2* CBURTestStepBackup2::NewL(CBURTestServer& aTestServer)
		/**
		Symbian OS Constructor
		
		@internalComponent
		@released
		
		@param aParent - The parent CBURTestServer of this child test step.
		@return Pointer to a newly created CBURTestStepBackup2 object.
		*/
		{
		CBURTestStepBackup2* self = new (ELeave) CBURTestStepBackup2(aTestServer);
		CleanupStack::PushL(self);
		self->ConstructL();
		CleanupStack::Pop();
		return self;
		}

	CBURTestStepBackup2::CBURTestStepBackup2(CBURTestServer& aTestServer)
		/**
		C++ Constructor
		
		@internalComponent
		@released
		
		@param aParent - The parent CBURTestServer of this child test step.
		*/
		: CBURTestStepBase(aTestServer), iDataTransferHandler(NULL)
		{}
	
	void CBURTestStepBackup2::ConstructL()
		/**
		Symbian OS 2nd-phase Constructor
		
		@internalComponent
		@released
		*/
		{
		TInt error;
		
		// Initialise the drive list to empty
		iDriveList.FillZ();
		
		User::LeaveIfError(iFs.Connect());
		
		// Install an active scheduler for this test step
		iActiveScheduler = new(ELeave) CActiveScheduler;
		CActiveScheduler::Install(iActiveScheduler);
		
		TRAP(error, iBackupClient = CSBEClient::NewL());
		if (error != KErrNone)
			{
			_LIT(KClientConnection, "SBEClientConnection");
			User::Panic(KClientConnection,error);
			}
			
		_LIT(KBURTBackup, "BURTestServerBackup");
		User::RenameThread(KBURTBackup);
		//User::SetCritical(User::ESystemCritical);
		
		SetTestStepName(KBURTestBackup2);
		}
	
	CBURTestStepBackup2::~CBURTestStepBackup2()
		/**
		C++ Destructor
		
		@internalComponent
		@released
		*/
		{
		delete iDataTransferHandler;
		}

	TVerdict CBURTestStepBackup2::doTestStepPreambleL()
		/**
		Override of base class virtual function
		
		@internalComponent
		@released
		
		@return TVerdict code
		*/
		{
		SetTestStepResult(EPass);
		return TestStepResult();
		}

	TVerdict CBURTestStepBackup2::doTestStepL()
		/**
		Override of base class pure virtual
		
		@internalComponent
		@released
		
		@return TVerdict code
		*/
		{
		_LIT(KLog1, "Processing user options...");
		Log(LOG_LEVEL2, KLog1);
		ProcessUserOptionsL();
		
		// Get a list of data owners:
		PopulateListOfDataOwnersL();
		
		TBURPartType type = EBURBackupFull;
		
		if (iIsPartial)
			{
			_LIT(KLog2, "Preparing for PARTIAL backup...");
			Log(LOG_LEVEL2, KLog2);
			type = EBURBackupPartial;
			PrepareForPartialBURL();
			SetSIDListForPartialL();
			}
		else
			{
			_LIT(KLog3, "Preparing for FULL backup...");
			Log(LOG_LEVEL2, KLog3);
			}
		
		CheckValidRegistrationL();
		
		_LIT(KLog4, "Saving Data Owners...");
		Log(LOG_LEVEL2, KLog4);
		SaveDataOwners();
		
		Log(LOG_LEVEL2, _L("Setting backup mode..."));
		TRAPD(err,SetBURModeL(type, iBackupIncType));
		if (err != KErrNone)
			{
			_LIT(KBURError, "Error setting Backup mode ");
			Log(LOG_LEVEL3, KBURError);
			}
		
		iDataTransferHandler = CAsyncBackupTransferHandler::NewL(this);
		Log(LOG_LEVEL2, _L("Starting backup..."));
		
		//BackupRegistrationDataL();
		
		BackupPublicDataL();
		
		BackupJavaMidletsL();
		BackupJavaMidletsDataL();
		
		// Backup data according to user preferences
		if (iBackupIncType == EBackupIncrement)
			{
			IncrementalBackupL();
			}
		else
			{
			BaseBackupL();
			}
		GetLargePublicFileListL();
		Log(LOG_LEVEL2, _L("Setting backup mode to Normal ..."));
		TRAPD(err2,SetBURModeL(EBURNormal, ENoBackup));
		if (err2 != KErrNone)
			{
			_LIT(KBURError, "Error setting Backup mode ");
			Log(LOG_LEVEL3, KBURError);
			}
		
		TestSetBURMode();
		
		return TestStepResult();
		}
	
	void CBURTestStepBackup2::BaseBackupL()
		/**
		@internalComponent
		@released
		*/
		{
		// system data
		BackupSystemBaseDataL();
		BackupSystemSnapshotDataL();
		
		//active
		BackupActiveBaseDataL();
		BackupActiveSnapshotDataL();
		
		//passive
		BackupPassiveBaseDataL();
		BackupPassiveSnapshotDataL();
		}
	
	void CBURTestStepBackup2::IncrementalBackupL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KInc, "Backup mode: INCREMENTAL");
		Log(LOG_LEVEL2, KInc);
		//active
		SupplySystemSnapshotDataL();
		SupplyActiveSnapshotDataL();
		SupplyPassiveSnapshotDataL();
		TRAPD(err,iBackupClient->AllSnapshotsSuppliedL());
		if (err != KErrNone)
			{
			_LIT(KSnapErr, "Error Supplying Snapshot Data ");
			LogWithNum(LOG_LEVEL3, KSnapErr, err);
			}
		else
			{
			_LIT(KSnap, "All Snapshots Supplied");
			Log(LOG_LEVEL3, KSnap);
			}
			
		// system data
		BackupSystemBaseDataL();
		BackupSystemSnapshotDataL();
		
		// active
		BackupActiveIncDataL();
		BackupActiveSnapshotDataL();
		
		//passive
		BackupPassiveIncDataL();
		BackupPassiveSnapshotDataL();
		}
		
	void CBURTestStepBackup2::BackupSystemBaseDataL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KLog, "Backup System Data ...");
		Log(LOG_LEVEL2, KLog);
		GeneratePIDTransferTypesL(iTransferTypes, ESystemData);
		DoBackupL();
		}

	void CBURTestStepBackup2::SupplyDataL(RTransferTypeArray& aTransferTypes, TRequestStatus& aStatus)
		{//added for coverage test
		TInt transferTypesCount = aTransferTypes.Count();
		for(TInt currentIndex = 0; currentIndex < transferTypesCount; ++currentIndex)
			{
			TInt error;		
			TInt increments = 0;
			TInt incrIndex = 1;
			
			TSBDerivedType dataType = aTransferTypes[currentIndex]->DerivedTypeL();
			
			// check for incremental data
			switch(dataType)
				{
				case ESIDTransferDerivedType:
					{
					CSBSIDTransferType* type = CSBSIDTransferType::NewL(aTransferTypes[currentIndex]);
					CleanupStack::PushL(type);
					
					_LIT(KSid, "Supplying data for ID: ");
					LogWithSID(LOG_LEVEL3, KSid, type->SecureIdL());
					
					if (type->DataTypeL() == EActiveIncrementalData || type->DataTypeL() == EPassiveIncrementalData)
						{
						increments = iStorageManager->TotalIncFiles(type);
						if (!increments)
							{
							_LIT(KErrorText2, "No increments found");
							Log(LOG_LEVEL4, KErrorText2);
							// cleanup
							CleanupStack::PopAndDestroy(type);
							continue;
							}
						else 
							{
							_LIT(KIncFound, "Number of increments found: ");
							LogWithNum(LOG_LEVEL4, KIncFound, increments);
							} // else if
						} // if
					CleanupStack::PopAndDestroy(type);
					}
					break;
				case EPackageTransferDerivedType:
					{
					// package stuff
					CSBPackageTransferType* pType = CSBPackageTransferType::NewL(aTransferTypes[currentIndex]);
					CleanupStack::PushL(pType);
					_LIT(KPid, "Supplying data for Package ID: ");
					LogWithSID(LOG_LEVEL3, KPid, pType->PackageIdL());
					CleanupStack::PopAndDestroy(pType);
					}
					break;
				case EJavaTransferDerivedType:
					{
					// java stuff
					CSBJavaTransferType* jType = CSBJavaTransferType::NewL(aTransferTypes[currentIndex]);
					CleanupStack::PushL(jType);
					_LIT(KJid, "Supplying data for Java SuiteHash: ");
					LogWithText(LOG_LEVEL3, KJid, jType->SuiteHashL());
					CleanupStack::PopAndDestroy(jType);
					}
					break;
				
				} // switch
			TBool runAgain = ETrue;		
			do 
				{
				TBool finished;				
				TPtr8* bufferPtr = NULL;
				TRAP(error, bufferPtr = &iBackupClient->TransferDataAddressL());
				if (error != KErrNone)
					{
					_LIT(KErrTDA, "Error getting TransferDataAddress: ");
					LogWithNum(LOG_LEVEL4, KErrTDA, error);
					break;
					}
				TRAP(error, iStorageManager->RetrieveDataL(aTransferTypes[currentIndex], *bufferPtr, finished, incrIndex));
				if (error != KErrNone)
					{
					iStorageManager->Reset();
					if (error == KErrPathNotFound || error == KErrNotFound)
						{
						_LIT(KErrorText2, "Data doesn't exists");
						Log(LOG_LEVEL4, KErrorText2);
						}
					else
						{
						_LIT(KErrorText1, "Error reading from archive: ");
						LogWithNum(LOG_LEVEL4, KErrorText1, error);
						iFailures++;
						}
					break;
					} 
				else
					{
					_LIT(KLogBytes, "Number of bytes to send: ");
					LogWithNum(LOG_LEVEL4, KLogBytes, bufferPtr->Length());	
			
					TRAP(error, iBackupClient->SupplyDataL(*aTransferTypes[currentIndex], finished, aStatus));
					if (error != KErrNone)
						{
						_LIT(KErrorText2, "Error supplying data to backup server: ");
						LogWithNum(LOG_LEVEL4, KErrorText2, error);
						if (iExpectStatus != error)
							iFailures++;
						break;
						}
					else
						{
						_LIT(KSuccess, "Operation finished successfully");
						Log(LOG_LEVEL4, KSuccess);
						}
					
					} // else
					
				if ((finished && !increments) || (incrIndex == increments && finished)) // if finished 
					{
					runAgain = EFalse;
					}
				else if (finished && incrIndex < increments) // is incremental data move to next increment
					{
					incrIndex++;
					runAgain = ETrue;
					}
				else 
					{
					runAgain = ETrue;
					}
				} // do
				while (runAgain);
			} // for
			
			if (!iFailures)
				{
				_LIT(KComp, "No errors found");
				Log(LOG_LEVEL3, KComp);
				}
		// Do not delete bufferPtr, as it gets deleted by the iBackupClient
		}
	
	void CBURTestStepBackup2::SupplySystemSnapshotDataL()
		/**
		@internalComponent
		@released
		*/
		{
		GeneratePIDTransferTypesL(iTransferTypes, ESystemSnapshotData);
		// go through each of them and check if we have snapshot to supply
		if (iTransferTypes.Count())
			{
			_LIT(KLog, "Supply System Snapshot Data ...");
			Log(LOG_LEVEL2, KLog);
			
			TRequestStatus status;
			SupplyDataL(iTransferTypes, status);
			}
		}
		
	void CBURTestStepBackup2::BackupSystemSnapshotDataL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KLog, "Backup System Snapshot Data ...");
		Log(LOG_LEVEL2, KLog);
		GeneratePIDTransferTypesL(iTransferTypes, ESystemSnapshotData);
		DoBackupL();
		}
	
	
	void CBURTestStepBackup2::BackupRegistrationDataL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KReg, "Backup registration data...");
		Log(LOG_LEVEL2, KReg);
		GenerateSIDTransferTypesL(iTransferTypes, ERegistrationData);
		DoBackupL();
		}
	
	void CBURTestStepBackup2::BackupPassiveSnapshotDataL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KPassSnap, "Backup passive snapshot data...");
		Log(LOG_LEVEL2, KPassSnap);
		GenerateSIDTransferTypesL(iTransferTypes, EPassiveSnapshotData);
		DoBackupL();
		}
	
	void CBURTestStepBackup2::SupplyPassiveSnapshotDataL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KSupp, "Supplying passive snapshot data...");
		Log(LOG_LEVEL2, KSupp);
		DoSupplyL(EPassiveSnapshotData);
		}

	void CBURTestStepBackup2::BackupPassiveBaseDataL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KPassBase, "Backup passive base data...");
		Log(LOG_LEVEL2, KPassBase);
		GenerateSIDTransferTypesL(iTransferTypes, EPassiveBaseData);
		DoBackupL();
		}
	
	void CBURTestStepBackup2::BackupPassiveIncDataL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KPassInc, "Backup passive incremental data...");
		Log(LOG_LEVEL2, KPassInc);
		GenerateSIDTransferTypesL(iTransferTypes, EPassiveIncrementalData);
		DoBackupL();
		}
	
	void CBURTestStepBackup2::BackupActiveSnapshotDataL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KActSnap, "Backup active snapshot data...");
		Log(LOG_LEVEL2, KActSnap);
		DoActiveBackupL(EActiveSnapshotData);
		}
	
	void CBURTestStepBackup2::SupplyActiveSnapshotDataL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KSuppActSnap,"Supplying active snapshot data...");
		Log(LOG_LEVEL2, KSuppActSnap);
		DoSupplyL(EActiveSnapshotData);
		}
	
	void CBURTestStepBackup2::BackupActiveBaseDataL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KActBase, "Backup active base data...");
		Log(LOG_LEVEL2, KActBase);
		DoActiveBackupL(EActiveBaseData);
		}

	void CBURTestStepBackup2::BackupActiveIncDataL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KActInc, "Backup active incremental data...");
		Log(LOG_LEVEL2, KActInc);
		DoActiveBackupL(EActiveIncrementalData);
		}
		
	void CBURTestStepBackup2::BackupPublicDataL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KPublic, "Backup Public Data...");
		Log(LOG_LEVEL2, KPublic);
		RPointerArray<CSBGenericDataType> array;
		TRAP_IGNORE(GeneratePublicTransferTypesL(array));
		TRAP_IGNORE(DoPublicBackupL(array));
		array.ResetAndDestroy();
		array.Close();
		}
		
	void CBURTestStepBackup2::DoPublicBackupL(RPointerArray<CSBGenericDataType>& aTransferTypes)
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KNote, "Public data is Not saved it just for Testing purposes to show the list of files got from the device!");
		Log(LOG_LEVEL2, KNote);
		RFileArray array;
		CleanupClosePushL(array);	
		
		TInt length = iDriveList.Length();
		TInt count = aTransferTypes.Count();
		for (TInt driveCount = 0; driveCount < length && count; driveCount++)
			{
			if (iDriveList[driveCount])
				{
				for (TInt i =0; i < count; i++)
					{
					iBackupClient->PublicFileListL(TDriveNumber(driveCount), *aTransferTypes[i], array);
					
					TInt fileCount = array.Count();
					_LIT(KFoundCount, "Found number of files: ");
					LogWithNum(LOG_LEVEL3, KFoundCount, fileCount);
					
					for (TInt j = 0; j < fileCount; j++)
						{
						_LIT(KFile, "Public File: ");
						LogWithText(LOG_LEVEL4, KFile, array[j].iName);
						}
					
					/** Only for one partial backup */
					if (iPublicFileNames.Count() > 0)
						{
						if (fileCount != iPublicFileNames.Count())
							{
							iFailures++;
							_LIT(KLogCount, "Backup count of public files don't match ");
							Log(LOG_LEVEL3, KLogCount);
							SetTestStepResult(TVerdict(EFail));				
							}
						
						for (TInt k=0; k<fileCount; ++k)
							{
							if (iPublicFileNames.Find(array[k].iName) == KErrNotFound) 
								{
								iFailures++;
								_LIT(KLogName, "Backup name of public files don't match ");
								Log(LOG_LEVEL3, KLogName);
								SetTestStepResult(TVerdict(EFail));										
								}
							}						
						}
					array.Reset();
					}
				}
			}
		CleanupStack::PopAndDestroy(&array);
		}
	
	void CBURTestStepBackup2::DoBackupL()
		/**
		Core backup method to carry out the transfer as well as the storage of 
		data to the archive.
		
		@internalComponent
		@released
		
		@param aDataType - Type of data to be backed up.
		*/
		{
		if (iTransferTypes.Count())
			{
			// STEP 2 - Start the data request handler to backup data:
			_LIT(KLog2, "Requesting backup data for IDs per drive...");
			Log(LOG_LEVEL3, KLog2);
			iDataTransferHandler->StartL();
			// Log success:
			if (iDataTransferHandler->Success())
				{
				_LIT(KLog3, "Operation finished with no errors");
				Log(LOG_LEVEL3, KLog3);
				} //if
			else
				{
				iFailures++;
				_LIT(KLog4, "Operation failed with errors ");
				Log(LOG_LEVEL3, KLog4);
				SetTestStepResult(TVerdict(EFail));
				} //else
			} //if 
		else 
			{
			_LIT(KLogNoTrans, "Nothing to do ");
			Log(LOG_LEVEL3, KLogNoTrans);
			} //else
		}
		
		
	void CBURTestStepBackup2::DoActiveBackupL(TTransferDataType aTransferDataType)
		/**
		@internalComponent
		@released
		*/
		{
		RTransferTypeArray transferTypes;
		GenerateSIDTransferTypesL(transferTypes, aTransferDataType);
		if (transferTypes.Count())
			{
			TRAPD(error,
			for (TInt i=0; i < KRetries;)
				{
				CheckSIDStatusL(transferTypes, iTransferTypes);													
				if (iTransferTypes.Count()) // dataowners ready
					{
					DoBackupL();
					} 
				else if (transferTypes.Count()) // data owners not ready
					{
					User::After(KDelay);
					i++;
					}
				else // finished with all sids
					{
					break;
					}
				} // for
				); //TRAPD
			if (transferTypes.Count())
				{
				iFailures++;
				_LIT(KLogNoTrans, "***Error: Some Data Owners were Not Ready or Failed to Connect");
				Log(LOG_LEVEL3, KLogNoTrans);
				} //if
			transferTypes.ResetAndDestroy();
			
			User::LeaveIfError(error);
			}
		else 
			{
			_LIT(KLogNoTrans, "Nothing to do ");
			Log(LOG_LEVEL3, KLogNoTrans);
			}

		}
		
	void CBURTestStepBackup2::BackupJavaMidletsL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KMidlet, "Backup midlets...");
		Log(LOG_LEVEL2, KMidlet);
		GenerateJavaTransferTypesL(iTransferTypes, EJavaMIDlet);
		DoBackupL();
		}
		
	void CBURTestStepBackup2::BackupJavaMidletsDataL()
		/**
		@internalComponent
		@released
		*/
		{
		_LIT(KMidletData, "Backup midlets data...");
		Log(LOG_LEVEL2, KMidletData);
		GenerateJavaTransferTypesL(iTransferTypes, EJavaMIDletData);
		DoBackupL();
		}
	
	TVerdict CBURTestStepBackup2::doTestStepPostambleL()
		/**
		@return - TVerdict code
		 Override of base class pure virtual
		*/
		{
		_LIT(KLog, "Number of failures:");
		LogWithNum(LOG_LEVEL3, KLog, iFailures);
		if (iFailures)
			{
			SetTestStepResult(TVerdict(EFail));
			}
		return TestStepResult();
		}
	void CBURTestStepBackup2::GetLargePublicFileListL()
		{
		//Coverage test get large public file list
		RPointerArray<CSBGenericDataType> transferTypes;
		CleanupResetAndDestroyPushL(transferTypes);
		TRAP_IGNORE(GeneratePublicTransferTypesL(transferTypes));
		RFileArray array;
		CleanupClosePushL(array);
		TInt length = iDriveList.Length();
		TInt count = transferTypes.Count();
		for (TInt driveCount = 0; driveCount < length && count; driveCount++)
			{
			if (iDriveList[driveCount])
				{
				for (TInt i =0; i < count; i++)
					{
					CBURActiveObject* active = CBURActiveObject::NewL();
					CleanupStack::PushL(active);					
					RPointerArray<CSBEFileEntry> fileEntry;
					TBool bFinish;
					CleanupClosePushL(fileEntry);
					iBackupClient->PublicFileListL(TDriveNumber(driveCount), *transferTypes[i], 
							fileEntry,
							bFinish,
							0,
							1024,
							active->iStatus);
					active->StartL();
					User::LeaveIfError(active->Error());
					TInt fileCount = fileEntry.Count();
					for (TInt j = 0; j < fileCount; j++)
						{
						_LIT(KFile, "File: ");
						LogWithText(LOG_LEVEL4, KFile, fileEntry[j]->Filename());
						}
					CleanupStack::PopAndDestroy(&fileEntry);
					CleanupStack::PopAndDestroy(active);

					_LIT(KFoundCount, "Get large file list and found number of files: ");
					LogWithNum(LOG_LEVEL3, KFoundCount, fileCount);
					array.Reset();
					}
				}
			}		
		CleanupStack::PopAndDestroy(&array);
		CleanupStack::PopAndDestroy(&transferTypes);
		
		//added for coverage test: test sbtypes
		if(iDataOwners.Count() > 0)
			{
			TDriveList& ref1 = iDataOwners[0]->DriveList();			
			HBufC8* hbuf = iDataOwners[0]->ExternaliseL();
			CSBGenericDataType& genDataType = iDataOwners[0]->Identifier();
			
			const CDataOwnerInfo& refDataOwner = *iDataOwners[0];
			const CSBGenericDataType& genDataType2 =refDataOwner.Identifier();
			const TDriveList& ref2 = refDataOwner.DriveList();
			
			_LIT(fname, "test.txt");
			TEntry entry;
			entry.iName = fname;
			
			RApaLsSession apaSession;
			User::LeaveIfError(apaSession.Connect());
			CleanupClosePushL(apaSession);
			CSBEFileEntry* sbeFile = CSBEFileEntry::NewLC(entry, apaSession);
			HBufC8* tmpBuf =sbeFile->ExternaliseLC();
			
			sbeFile->FileAttributes();
			sbeFile->Filename();
			sbeFile->FileSize();
			sbeFile->LastModified();
			sbeFile->MIMEType();
			sbeFile->MIMEUid();			
			
			TInt count;
			CSBEFileEntry* sbeFile2= CSBEFileEntry::NewLC(*tmpBuf, count);
						
			CleanupStack::PopAndDestroy(sbeFile2);
			CleanupStack::PopAndDestroy(tmpBuf);
			CleanupStack::PopAndDestroy(sbeFile);
			CleanupStack::PopAndDestroy(&apaSession);
			}		
		}
	
	void CBURTestStepBackup2::TestSetBURMode()
		{
		TRAPD(err, SetBURModeL(EBURUnset, EBackupBase));
		TRAP(err, SetBURModeL(EBURUnset, EBackupBase));
		TRAP(err, SetBURModeL(EBURNormal, EBackupBase));
		TRAP(err, SetBURModeL(EBURNormal, EBackupBase));
		TRAP(err, SetBURModeL(EBURUnset, EBackupBase));
		TRAP(err, SetBURModeL(EBURUnset, EBackupBase));
		
		TSecureId sid(0x10202BE9);
		HBufC* hbuf = NULL;
		
		//this method is not implemented at server side
		TRAP(err, iBackupClient->PublicFileListXMLL(EDriveC, sid, hbuf));
		
		TRAP(err, SetBURModeL(EBURBackupFull, EBackupBase));
		
		//this method is not implemented at server side
		TRAP(err, iBackupClient->PublicFileListXMLL(EDriveC, sid, hbuf));
		
		TRAP(err, SetBURModeL(EBURBackupFull, EBackupBase));
		TRAP(err, SetBURModeL(EBURBackupPartial, EBackupBase));
				
		TRAP(err, SetBURModeL(EBURBackupPartial, EBackupIncrement));
		TRAP(err, SetBURModeL(EBURBackupFull, EBackupIncrement));		
		
		{//this operation is expected to fail
			TRAP(err, PopulateListOfDataOwnersL());
			iFailures--;
		}
		
		TRAP(err, SetBURModeL(EBURBackupPartial, ENoBackup));
		TRAP(err, SetBURModeL(EBURBackupFull, ENoBackup));		
		
		TRAP(err, SetBURModeL(EBURRestoreFull, EBackupBase));
		TRAP(err, SetBURModeL(EBURRestorePartial, EBackupBase));
				
		TRAP(err, SetBURModeL(EBURRestoreFull, EBackupIncrement));
		TRAP(err, SetBURModeL(EBURRestorePartial, EBackupIncrement));
		
		TRAP(err, SetBURModeL(EBURRestoreFull, ENoBackup));
		TRAP(err, SetBURModeL(EBURRestorePartial, ENoBackup));
		TRAP(err, SetBURModeL(EBURNormal, EBackupBase));
		
		//this method is not implemented at server side
		TRAP(err, iBackupClient->PublicFileListXMLL(EDriveC, sid, hbuf));
		}
	}	// end namespace