--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/backupandrestore/backuptest/burtestserver/TestSteps/src/t_teststepbackup2.cpp Tue Feb 02 01:11:40 2010 +0200
@@ -0,0 +1,869 @@
+// 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>
+
+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;
+ CleanupClosePushL(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