diff -r 000000000000 -r b16258d2340f applayerpluginsandutils/bookmarksupport/test/tbackuptest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/applayerpluginsandutils/bookmarksupport/test/tbackuptest.cpp Tue Feb 02 01:09:52 2010 +0200 @@ -0,0 +1,519 @@ +// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include +#include "testutils.h" +#include "tbookmarktests.h" + +#include +#include +#include +#include +#include + +#include "srvrepos.h" +#include "srvres.h" +#include "cachemgr.h" +#include "backup.h" + +#define TEST2(aValue, aExpected) ::CheckL(aValue, aExpected) + +_LIT ( KMyFolder, "BackupFolder" ); +_LIT(KTxtBookmark1, "Bookmark 1"); +_LIT8(KBookmarkUri, "www.ft.com"); +_LIT(KTitle, "Bookmark Backup Restore Test"); +LOCAL_D RTest gTest(KTitle()); + +LOCAL_D CTestWrapper* gTestWrapper; +CActiveScheduler* globalAS; + +CRepositoryBackupClient* backupClient; + +CDesC8ArraySeg* originalData1; +CDesC8ArraySeg* originalData2; + +_LIT_SECURE_ID( SecureId1, 0x102078CB ); + +_LIT( K10205af8, "10205AF8.txt" ); +_LIT( K10205af9, "10205AF9.txt" ); +_LIT( K10205afa, "10205AFA.txt" ); +_LIT( K10205afb, "10205AFB.txt" ); + +const TUid KUidBookmarkDatabaseRepository = { 0x10205AF8 }; +const TUid KUidFolderRepository = { 0x10205AF9 }; +const TUid KUidBookmarkRepository = { 0x10205AFA }; +const TUid KUidIconRepository = { 0x10205AFB }; + + +LOCAL_C void ResetRepositoryL ( TUid aUid ) + { + CRepository* repository = CRepository::NewL ( aUid ); + CleanupStack::PushL ( repository ); + User::LeaveIfError ( repository->Reset() ); + CleanupStack::PopAndDestroy ( repository ); + } + + + +/** +Creates a database. +Creates a folder. +Creates a bookmark. +*/ +LOCAL_C void CreateBookmarkInFolderL() + { + + //This will ensure that the old repositories are deleted + ResetRepositoryL ( KUidBookmarkDatabaseRepository ); + ResetRepositoryL ( KUidFolderRepository ); + ResetRepositoryL ( KUidBookmarkRepository ); + ResetRepositoryL ( KUidIconRepository ); + + // Open the database + RBkDatabase database; + database.OpenL(); + CleanupClosePushL(database); + + //Create a folder + RBkFolder folder = database.CreateFolderL(KMyFolder); + CleanupClosePushL(folder); + + // Create a bookmark in the new folder + RBkBookmark bmrk = database.CreateBookmarkL(&folder); + CleanupClosePushL(bmrk); + + // Set some bookmark properties + bmrk.SetTitleL(KTxtBookmark1); + bmrk.SetUriL(KBookmarkUri); + + // Close the bookmark + CleanupStack::PopAndDestroy(&bmrk); + + // Close the folder + CleanupStack::PopAndDestroy(&folder); + + // Commit the changes to the database and close it + database.CommitL(); + CleanupStack::PopAndDestroy(&database); + + gTest.Printf(_L("\n*** Created database, folder, bookmark ***\n")); + } + + +/** +Deletes all the files in the temporary repository folder. +The temporary repository folder used is 10281FE5. +*/ +LOCAL_C void DeleteFilesL() + { + _LIT( KOldInstallFiles, "c:\\private\\10281FE5\\*.*" ); + _LIT( KOldPersistFiles, "c:\\private\\10281FE5\\persists\\*.*" ); + + CFileMan* fm = CFileMan::NewL( TServerResources::iFs ); + CleanupStack::PushL( fm ); + + TInt r = fm->Delete( KOldInstallFiles ); + if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound ) + User::Leave(r); + r = fm->Delete( KOldPersistFiles ); + if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound ) + User::Leave(r); + + gTest.Printf(_L("\n*** Deleted files from temporary repository ***\n")); + CleanupStack::PopAndDestroy( fm ); + } + + +/** +Deletes all the files in the original bookmarks repository folder. +The bookmarks repository folder is 10202be9 +*/ +LOCAL_C void DeleteRepositoryFilesL() + { + _LIT( KOldInstallFiles, "c:\\private\\10202be9\\*.cre" ); + _LIT( KOldPersistFiles, "c:\\private\\10202be9\\persists\\*.cre" ); + + CFileMan* fm = CFileMan::NewL( TServerResources::iFs ); + CleanupStack::PushL( fm ); + + TInt r = fm->Delete( KOldInstallFiles ); + if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound ) + User::Leave(r); + r = fm->Delete( KOldPersistFiles ); + if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound ) + User::Leave(r); + + gTest.Printf(_L("\n*** Deleted files from original repository ***\n")); + CleanupStack::PopAndDestroy( fm ); + } + + +LOCAL_C void CheckL( TInt aValue, TInt aExpected) + { + if ( aValue != aExpected ) + { + DeleteFilesL(); + RDebug::Print( _L( "*** Expected error: %d, got: %d\r\n"), aExpected, aValue ); + } + } + +/** +Does a copy of the config files from the ROM area to the temporary repository folder. +The bookmark component has 4 config files 10205AF8.txt, 10205AF9.txt, 10205AFA.txt and +10205AFB.txt. +*/ +LOCAL_C void InstallFileSetL(const TDesC& afilename) + { + _LIT( KFileSrcPath, "\\private\\10202be9\\" ); + _LIT( KInstallFileDestPath, "\\private\\10281FE5\\" ); + _LIT( KPersistFileDestPath, "\\private\\10281FE5\\persists\\" ); + _LIT( KDriveC, "c:" ); + _LIT( KDriveZ, "z:" ); + + TBuf dest; + TBuf src; + TBuf src2; + TBuf dest2; + TInt r; + + CFileMan* fm = CFileMan::NewL( TServerResources::iFs ); + CleanupStack::PushL( fm ); + + dest.Copy( KDriveC ); + dest.Append( KInstallFileDestPath ); + dest.Append( afilename ); + r = fm->Delete( dest ); + if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound ) + User::Leave( r ); + r = TServerResources::iFs.MkDirAll( dest ); + if ( r != KErrNone && r != KErrAlreadyExists ) + User::Leave( r ); + + src.Copy( KDriveZ ); + src.Append( KFileSrcPath ); + src.Append( afilename ); + User::LeaveIfError( fm->Copy( src, dest ) ); + r = fm->Attribs( dest, KEntryAttArchive, KEntryAttReadOnly, TTime( 0 ), CFileMan::ERecurse ); + TEST2( r, KErrNone ); + + dest2.Copy( KDriveC ); + dest2.Append( KPersistFileDestPath ); + dest2.Append( afilename ); + r = fm->Delete( dest2 ); + if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound ) + User::Leave( r ); + r = TServerResources::iFs.MkDirAll( dest2 ); + if ( r != KErrNone && r != KErrAlreadyExists ) + User::Leave( r ); + src2.Copy( KDriveZ ); + src2.Append( KFileSrcPath ); + src2.Append( afilename ); + User::LeaveIfError( fm->Copy( src2, dest2 ) ); + r = fm->Attribs( dest2, KEntryAttArchive, KEntryAttReadOnly, TTime( 0 ), CFileMan::ERecurse ); + TEST2( r, KErrNone ); + + CleanupStack::PopAndDestroy( fm ); + } + + +/** +Does the backup of the repository. +*/ +LOCAL_C void BackupRepositoryL( CDesC8ArraySeg* aDataStream ) + { + backupClient->CompleteOwnerIdLookupTableL(); + + //The SecureId1 has to be the same as the value for [owner] tag in each of the + //config files + backupClient->InitialiseGetProxyBackupDataL( SecureId1, EDriveC ); + + HBufC8* transferBuffer = HBufC8::NewL( 128 ); + CleanupStack::PushL( transferBuffer ); + TPtr8 bufferToSend = transferBuffer->Des(); + TBool finished = EFalse; + + aDataStream->Reset(); + + do + { + bufferToSend.Zero(); + backupClient->GetBackupDataSectionL( bufferToSend, finished ); + aDataStream->AppendL( bufferToSend ); + } while ( !finished ); + + gTest.Printf(_L("\n*** Backup process completed successfully ***\n")); + CleanupStack::PopAndDestroy( transferBuffer ); + } + + +/** +Does a restore of the backed up data. +@param aDataStream + Carries the backed up data. +*/ +LOCAL_C void RestoreRepositoryL( CDesC8ArraySeg* aDataStream ) + { + backupClient->InitialiseRestoreProxyBaseDataL( SecureId1, EDriveC ); + + HBufC8* transferBuffer = HBufC8::NewL( 128 ); + CleanupStack::PushL( transferBuffer ); + TPtr8 bufferToSend = transferBuffer->Des(); + + TBool finished = EFalse; + TInt count = aDataStream->Count(); + TInt element = 0; + + for ( element = 0; element < count; element++ ) + { + bufferToSend.Zero(); + bufferToSend.Append( (*aDataStream)[ element ] ); + if ( element + 1 == count ) + finished = ETrue; + backupClient->RestoreBaseDataSectionL( bufferToSend, finished ); + } + backupClient->RestoreComplete( EDriveC ); + + gTest.Printf(_L("\n*** Restoration completed successfully ***\n")); + CleanupStack::PopAndDestroy( transferBuffer ); + } + + +/** +Initializes the descriptors required for the backup and restore process +*/ +LOCAL_C void InitializationLC() + { + originalData1 = new(ELeave)CDesC8ArraySeg( 128 ); + CleanupStack::PushL( originalData1 ); + originalData2 = new(ELeave)CDesC8ArraySeg( 128 ); + CleanupStack::PushL( originalData2 ); + } + + +/** +Cleans up the used resources +*/ +LOCAL_C void CleanupL() + { + CleanupStack::PopAndDestroy( originalData2 ); + CleanupStack::PopAndDestroy( originalData1 ); + } + + +/** +Move the restored (.cre) files from the temporary repository folder to the original repository +folder. +*/ +LOCAL_C void MoveFilesToOriginalRepositoryL() +{ + _LIT( KFileSrcPath, "\\private\\10281FE5\\persists\\" ); + _LIT( KFileDestPath, "\\private\\10202be9\\persists\\" ); + _LIT( KDriveC, "c:" ); + _LIT( KAllFiles, "*.*"); + + TBuf dest; + TBuf src; + TInt r; + + CFileMan* fm = CFileMan::NewL( TServerResources::iFs ); + CleanupStack::PushL( fm ); + + dest.Copy( KDriveC ); + dest.Append( KFileDestPath ); + dest.Append( KAllFiles ); + r = TServerResources::iFs.MkDirAll( dest ); + if ( r != KErrNone && r != KErrAlreadyExists ) + User::Leave( r ); + src.Copy( KDriveC ); + src.Append( KFileSrcPath ); + src.Append( KAllFiles ); + User::LeaveIfError( fm->Copy( src, dest ) ); + r = fm->Attribs( dest, KEntryAttArchive, KEntryAttReadOnly, TTime( 0 ), CFileMan::ERecurse ); + TEST2( r, KErrNone ); + + gTest.Printf(_L("\n*** Restored files to original repository ***\n")); + CleanupStack::PopAndDestroy( fm ); +} + + +LOCAL_D TBool IsItemInFolderL(const TDesC& aName, RBkFolder& aFolder) + { + RBkNode item; + TBool found = EFalse; + TInt index = aFolder.Count() - 1; + for (;index >= 0; --index) + { + item = aFolder.OpenItemL(index); + CleanupClosePushL(item); + const TDesC& title = item.Title(); + if (title.Compare(aName) == 0) + { + found = ETrue; + } + CleanupStack::PopAndDestroy(&item); + if (found) + { + break; + } + } + return found; + } + + +/** +Checks if the Repository is restored along with the foleder and the bookmark created +previously +*/ +LOCAL_C void CheckRepositoryL() +{ + RBkDatabase database1; + database1.OpenL(); + CleanupClosePushL(database1); + + RBkFolder folder; + TRAPD(err1, folder = database1.OpenFolderL(KMyFolder)); + gTestWrapper->TEST(err1 == KErrNone); + CleanupClosePushL(folder); + + gTestWrapper->TEST(IsItemInFolderL(KTxtBookmark1, folder)); + + CleanupStack::PopAndDestroy(&folder); + CleanupStack::PopAndDestroy(&database1); +} + + + +/** +Creates a bookmark database. Cretes a temporary repository folder with the repositories in it. +Does a backup and a restore to the temporary repository and then to the original repository and +deletes the temporary repository. +*/ +LOCAL_C void INC081573L() + { + // create and install the active scheduler we need + CActiveScheduler* s = new(ELeave) CActiveScheduler; + CleanupStack::PushL( s ); + CActiveScheduler::Replace( s ); + + //Create folder and bookmark + CreateBookmarkInFolderL(); + + backupClient = CRepositoryBackupClient::NewLC(TServerResources::iFs); + + TServerResources::iCacheManager->DisableCache(); + + gTest.Printf(_L("\n*** File installation started ***\n")); + + // Install known files + InstallFileSetL(K10205af8); + InstallFileSetL(K10205af9); + InstallFileSetL(K10205afa); + InstallFileSetL(K10205afb); + + gTest.Printf(_L("\n*** File installation completed successfully ***\n")); + + // backup known files, + BackupRepositoryL( originalData1 ); + + // delete files + DeleteFilesL(); + + //delete repository files + DeleteRepositoryFilesL(); + + // restore when other files do not exist + RestoreRepositoryL( originalData1 ); + + //move files back to repository + MoveFilesToOriginalRepositoryL(); + + //delete the temporary repository + DeleteFilesL(); + + CleanupStack::PopAndDestroy( backupClient ); + + // Cleanup the scheduler + CActiveScheduler::Replace( globalAS ); + CleanupStack::PopAndDestroy( s ); + + CheckRepositoryL(); + } + + +/** +Starts the backup and restore tests +*/ +void DoBackupTestL() + { + InitializationLC(); + + INC081573L(); + + TServerResources::iOwnerIdLookUpTable.Reset(); + + CleanupL(); + } + + +LOCAL_C void MainL() + { + __UHEAP_MARK; + gTest.Start( _L( "\n*** Backup and restore tests ***\n" ) ); + + gTest.Printf(_L("@SYMTestCaseID IWS-APPPROTOCOLS-BOOKMARKS-TBACKUPTEST-0001 ")); + + // create and install the active scheduler we need for the cache manager in TServerResources::InitialiseL + globalAS=new(ELeave) CActiveScheduler; + CleanupStack::PushL(globalAS); + CActiveScheduler::Install(globalAS); + + + TServerResources::InitialiseL(); + + gTestWrapper = CTestWrapper::NewLC(gTest); + gTestWrapper->Start(_L("\n*** Bookmark Test ***\n")); + + DoBackupTestL(); + + gTestWrapper->End(); + CleanupStack::PopAndDestroy(gTestWrapper); + + TServerResources::Close(); + CleanupStack::PopAndDestroy(globalAS); + + gTest.End(); + gTest.Close(); + __UHEAP_MARKEND; + } + + +TInt E32Main() + { + __UHEAP_MARK; + CTrapCleanup* cleanup = CTrapCleanup::New(); + if ( !cleanup ) + return KErrNoMemory; + + TRAPD( err, MainL() ); + if ( err != KErrNone ) + User::Panic( _L( "Testing failed: " ), err ); + + delete cleanup; + __UHEAP_MARKEND; + + return 0; + } + +