diff -r b8bdbc8f59c7 -r 7d4490026038 persistentstorage/sql/TEST/t_sqlbur.cpp --- a/persistentstorage/sql/TEST/t_sqlbur.cpp Thu Aug 12 11:53:23 2010 +0100 +++ b/persistentstorage/sql/TEST/t_sqlbur.cpp Mon Sep 27 11:59:56 2010 +0100 @@ -25,45 +25,93 @@ RTest TheTest(_L("SQL Backup and Restore Test")); -_LIT(KPrivateDir, "C:\\private\\10281e17\\"); +_LIT(KPrivateDir, "\\private\\10281e17\\"); -const TUid KClientUid = {0x21212122}; // the data owner's UID +//Don't forget to update DeleteBackupFiles() implementation if a new uid is added +const TSecureId KClientUid = 0x21212122; // the data owner's UID +const TSecureId KZeroFileSizeUid = 0xFFFF4321; +const TSecureId KTestClientUid1 = 0xFFFF4322; +const TSecureId KTestClientUid2 = 0xFFFF4323; +const TSecureId KTestClientUid3 = 0xFFFF4324; _LIT(KBackupDir, "C:\\TEST\\"); -_LIT(KBackupFile, "C:\\TEST\\Backup.bak"); +_LIT(KBackupFileTemplate, "C:\\TEST\\Backup.bak"); +_LIT(KBackupCopy, "C:\\TEST\\Backup2.bak"); _LIT(KBackupFile2Z, "Z:\\TEST\\t_sqlbur_backup_ver0.bak"); _LIT(KBackupFile2, "C:\\TEST\\t_sqlbur_backup_ver0.bak"); +_LIT(KZeroSizeFile, "C:\\private\\10281e17\\[FFFF4321]t_sqlbur_zero.db"); +_LIT(KTestFile1, "C:\\private\\10281e17\\[FFFF4322]t_sqlbur_test1.db"); +_LIT(KTestFile1NameOnly, "[FFFF4322]t_sqlbur_test1.db"); +_LIT(KTestFile1Bak, "C:\\private\\10281e17\\bak[FFFF4322]t_sqlbur_test1.db.bak"); +_LIT(KTestDeleteMask1, "C:\\private\\10281e17\\[FFFF4322]*"); +_LIT(KTestDeleteMask2, "*bur_test1.db"); +_LIT(KTestFile2, "\\private\\10281e17\\[FFFF4323]t_sqlbur_test2.db"); +_LIT(KTestFile3, "c:\\private\\10281e17\\[FFFF4324]t_sqlbur_test3.db"); +_LIT(KTestFile4, "c:\\private\\10281e17\\[FFFF4324]t_sqlbur_test4.db"); + +const TDriveNumber KTestDrive = EDriveC; + const TUint KBufferSize = 2048; // used for reading backup files for validation static CActiveScheduler* TheScheduler = NULL; -static CSqlBurTestHarness* TheTestHarness = NULL; +static CSqlSrvTestBurInterface* TheSqlSrvTestBurInterface = NULL; ///////////////////////////////////// -const TInt KMaxDbFileSize = 10 * 1024;//The max test db file size -const TInt KTestDbFileCnt = 2; - //Test db files -_LIT(KTestFileName1,"[21212122]AADB2.db");//Created outside this test app -_LIT(KTestFileName2,"[21212122]BBDB2.db");//Created outside this test app _LIT(KTestDbFileName1,"C:[21212122]AADB2.db"); _LIT(KTestDbFileName2,"C:[21212122]BBDB2.db"); -const TPtrC KTestFileNames[KTestDbFileCnt] = {KTestFileName1(), KTestFileName2()}; - -static TInt TheDbFileSizes[KTestDbFileCnt];//An array where the real db file size will be stored -static TUint8 TheDbFileData[KTestDbFileCnt][KMaxDbFileSize];//An array where the original db file content will be stored +//Temp buffers for storing files content, to be compared with what is received after the restore operation. 10 files max. +TInt TheFileCount = 0; +const TInt KMaxDbFileSize = 10 * 1024;//The max test db file size - 10 Kb max. +static TUint8 TheDbFileData[10][KMaxDbFileSize];//An array where the original db file content will be stored +static TInt TheDbFileSizes[10];//An array where the real db file size will be stored static TUint8 TheBuf[KMaxDbFileSize]; ///////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////// +void DeleteBackupFiles() + { + TFileName fname; + + fname.Copy(KBackupFileTemplate); + fname.Append((static_cast (KClientUid)).Name()); + (void)TheSqlSrvTestBurInterface->Fs().Delete(fname); + + fname.Copy(KBackupFileTemplate); + fname.Append((static_cast (KZeroFileSizeUid)).Name()); + (void)TheSqlSrvTestBurInterface->Fs().Delete(fname); + + fname.Copy(KBackupFileTemplate); + fname.Append((static_cast (KTestClientUid1)).Name()); + (void)TheSqlSrvTestBurInterface->Fs().Delete(fname); + + fname.Copy(KBackupFileTemplate); + fname.Append((static_cast (KTestClientUid2)).Name()); + (void)TheSqlSrvTestBurInterface->Fs().Delete(fname); + + fname.Copy(KBackupFileTemplate); + fname.Append((static_cast (KTestClientUid3)).Name()); + (void)TheSqlSrvTestBurInterface->Fs().Delete(fname); + } + void TestEnvDestroy() { - delete TheTestHarness; - TheTestHarness = NULL; + (void)TheSqlSrvTestBurInterface->Fs().Delete(KBackupCopy); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1Bak); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile3); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile4); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KZeroSizeFile); + + DeleteBackupFiles(); + + delete TheSqlSrvTestBurInterface; + TheSqlSrvTestBurInterface = NULL; delete TheScheduler; TheScheduler = NULL; @@ -96,32 +144,40 @@ /////////////////////////////////////////////////////////////////////////////////////// -//CSqlBurTestHarness - test implementation of the MSqlSrvBurInterface, implemented in the production code by the SQL server. -CSqlBurTestHarness *CSqlBurTestHarness::New() +static void DestroyFileList(RArray& aFileList) { - CSqlBurTestHarness* self = new CSqlBurTestHarness; + for(TInt i=0;iConstruct(); return self; } -CSqlBurTestHarness::CSqlBurTestHarness() +CSqlSrvTestBurInterface::CSqlSrvTestBurInterface() { } -void CSqlBurTestHarness::Construct() +void CSqlSrvTestBurInterface::Construct() { TInt err = iFs.Connect(); TEST2(err, KErrNone); err = iFs.MkDir(KBackupDir); TEST(err == KErrNone || err == KErrAlreadyExists); - err = iFs.CreatePrivatePath(EDriveC); + err = iFs.CreatePrivatePath(KTestDrive); TEST2(err, KErrNone); } -CSqlBurTestHarness::~CSqlBurTestHarness() +CSqlSrvTestBurInterface::~CSqlSrvTestBurInterface() { - (void)iFs.Delete(KBackupFile); iFs.Close(); } @@ -129,51 +185,57 @@ //The array is owned by the caller //The SQL server would have the job to get a list of databases owned by //the given SID and to determine whether the backup flag is set -//All databases that satisfy this requirement will be added to the array -void CSqlBurTestHarness::GetBackUpListL(TSecureId aUid, RArray& aFileList) +//All databases that satisfy this requirement will be added to the array. +void CSqlSrvTestBurInterface::GetBackUpListL(TSecureId aUid, TDriveNumber aDrive, RArray& aFileList) { if(aUid.iId == 0) {//Simulates that there are no databases for backup - aFileList.Reset(); + DestroyFileList(aFileList); return; } - //TheTest.Printf(_L("Getting backup file list for SID=%x\r\n"),aUid); - for(TInt i=0;i (aUid)).Name(); + _LIT(KMatchAllDbFiles, "*"); + TBuf fileNameMask(uidName); + fileNameMask.Append(KMatchAllDbFiles); + TParse parse; + TInt err = parse.Set(path, &fileNameMask, NULL); + User::LeaveIfError(err); + //Do the search + TPtrC fullPath(parse.FullName()); + CDir* fileNameCol = NULL; + err = TheSqlSrvTestBurInterface->Fs().GetDir(fullPath, KEntryAttNormal, ESortNone, fileNameCol); + if(err == KErrNotFound) { - TParse parse; - parse.Set(KTestFileNames[i], &KPrivateDir, NULL); - aFileList.AppendL(parse); + return; } - } - -//Notification that a backup is starting -TBool CSqlBurTestHarness::StartBackupL(const RArray& /*aFileList*/) - { - //TheTest.Printf(_L("Start \"backup\". %d files in the list.\r\n"), aFileList.Count()); - return ETrue; + User::LeaveIfError(err); + CleanupStack::PushL(fileNameCol); + TInt fileCount = fileNameCol->Count(); + err = aFileList.Reserve(fileCount); + User::LeaveIfError(err); + //Append the full database file paths to the file names list. + for(TInt i=0;i& /*aFileList*/) - { - //TheTest.Printf(_L("End \"backup\". %d files in the list.\r\n"), aFileList.Count()); - } - -//Notification that a restore is starting -TBool CSqlBurTestHarness::StartRestoreL(TSecureId /*aUid*/) - { - //TheTest.Printf(_L("Start \"restore\" for UID=%X\r\n"), aUid); - return ETrue; - } - -//Notification that a restore has ended -void CSqlBurTestHarness::EndRestore(TSecureId /*aUid*/) - { - //TheTest.Printf(_L("End \"restore\" for UID=%X\r\n"), aUid); - } - //Returns the file system resource handle to the caller. -RFs& CSqlBurTestHarness::Fs() +RFs& CSqlSrvTestBurInterface::Fs() { return iFs; } @@ -195,18 +257,54 @@ CActiveScheduler::Install(TheScheduler); - TheTestHarness = CSqlBurTestHarness::New(); - TEST(TheTestHarness != NULL); + TheSqlSrvTestBurInterface = CSqlSrvTestBurInterface::New(); + TEST(TheSqlSrvTestBurInterface != NULL); + } + +void PrepareSearchPath(TDriveNumber aDrive, TDes& aPath) + { + TDriveUnit driveUnit(aDrive); + TDriveName driveName = driveUnit.Name(); + aPath.Copy(driveName); + aPath.Append(KPrivateDir); + } + +void PrepareSearchPattern(const TDesC& aPath, TSecureId aUid, TParse& aParse) + { + TUidName uidName = (static_cast (aUid)).Name(); + _LIT(KMatchAllDbFiles, "*"); + TBuf fileNameMask(uidName); + fileNameMask.Append(KMatchAllDbFiles); + TInt err = aParse.Set(aPath, &fileNameMask, NULL); + TEST2(err, KErrNone); } //Reads the content of the db files and stores the content to a global memory buffer. //That buffer content will be used later for verification of the restore process. -void StoreDbContentToBuf(RFs& aFs) +void StoreDbContentToBuf(RFs& aFs, TDriveNumber aDrive, TSecureId aUid) { - for(TInt i=0;iCount(); + for(TInt i=0;iCount()); + for(TInt i=0;i 0); + const ::TEntry& entry = (*dir)[i]; + err = parse.Set(path, &entry.iName, NULL); + TEST2(err, KErrNone); + TPtrC fname(parse.FullName()); + RFile dbFile; - TInt err = dbFile.Open(aFs, KTestFileNames[i], EFileRead); + TInt err = dbFile.Open(aFs, fname, EFileRead); TEST2(err, KErrNone); TInt fileSize = 0; err = dbFile.Size(fileSize); TEST2(err, KErrNone); TEST(fileSize > 0); - TEST(TheDbFileSizes[i] == fileSize); + TEST2(TheDbFileSizes[i], fileSize); TPtr8 bufptr(TheBuf, 0, KMaxDbFileSize); err = dbFile.Read(bufptr, fileSize); TEST2(err, KErrNone); - TEST(fileSize == bufptr.Length()); + TEST2(fileSize, bufptr.Length()); err = Mem::Compare(TheBuf, fileSize, TheDbFileData[i], TheDbFileSizes[i]); TEST2(err, 0); dbFile.Close(); } + delete dir; } //////////////////////////////////////////////////////////////////////////////////////// @@ -261,13 +375,17 @@ //The backup client will return a series of data chunks representing //one of more databases for the uid of the data owner. //This data is stored in a file on the C drive for the purposes of the test -TInt TestBackupL(CSqlBackupClient &aBackupClient, RFs& aFs, TInt aDataChunkSize = KBufferSize) +TInt TestBackupL(CSqlBurCallback &aBackupClient, RFs& aFs, TSecureId aUid, TDriveNumber aDrive, TInt aDataChunkSize = KBufferSize) { + TFileName backupFileName; + backupFileName.Copy(KBackupFileTemplate); + backupFileName.Append((static_cast (aUid)).Name()); + RFile file; CleanupClosePushL(file); - TInt err = file.Replace(aFs, KBackupFile, EFileWrite | EFileStream | EFileShareExclusive); + TInt err = file.Replace(aFs, backupFileName, EFileWrite | EFileStream | EFileShareExclusive); User::LeaveIfError(err); - aBackupClient.InitialiseGetProxyBackupDataL(KClientUid, EDriveC); + aBackupClient.InitialiseGetProxyBackupDataL(aUid, aDrive); TBuf8 buf; TPtr8 ptr((TUint8*)buf.Ptr(), aDataChunkSize); @@ -290,7 +408,7 @@ { User::Leave(KErrEof); } - if(!FileExists(aFs, KBackupFile)) + if(!FileExists(aFs, backupFileName)) { User::Leave(KErrNotFound); } @@ -300,13 +418,17 @@ //This sends the data in chunks form back to the BUR client //for nupacking and restoration of the original databases files -TInt TestRestoreL(CSqlBackupClient &aRestoreClient, RFs& aFs, TInt aDataChunkSize = KBufferSize) +TInt TestRestoreL(CSqlBurCallback &aRestoreClient, RFs& aFs, TSecureId aUid, TDriveNumber aDrive, TInt aDataChunkSize = KBufferSize) { + TFileName backupFileName; + backupFileName.Copy(KBackupFileTemplate); + backupFileName.Append((static_cast (aUid)).Name()); + RFile file; CleanupClosePushL(file); - TInt err = file.Open(aFs, KBackupFile, EFileRead | EFileShareExclusive); + TInt err = file.Open(aFs, backupFileName, EFileRead | EFileShareExclusive); User::LeaveIfError(err); - aRestoreClient.InitialiseRestoreProxyBaseDataL(KClientUid, EDriveC); + aRestoreClient.InitialiseRestoreProxyBaseDataL(aUid, aDrive); TBuf8 buf; TPtr8 ptr((TUint8*)buf.Ptr(), aDataChunkSize); @@ -330,31 +452,28 @@ CleanupStack::PopAndDestroy(&file); - aRestoreClient.RestoreComplete(EDriveC); + aRestoreClient.RestoreComplete(aDrive); if(!finishedFlag) { User::Leave(KErrEof); } - for(TInt i=0;i (aUid)).Name()); - TInt err = bkpFile.Open(aFs, KBackupFile, EFileRead | EFileShareExclusive); + TInt err = bkpFile.Open(aFs, backupFileName, EFileRead | EFileShareExclusive); User::LeaveIfError(err); TBuf8 buf; @@ -473,9 +592,11 @@ bkpFileSize -= fileSize; // checksum the file - TUint32 dbChecksum = aBackupClient.CheckSumL(dbFile) & 0xFFFFFFFF; + TUint64 checkSum64 = 0; + User::LeaveIfError(aBackupClient.CheckSum(dbFile, checkSum64)); + TUint32 checksum32 = checkSum64 & 0xFFFFFFFF; - if(checksum != dbChecksum) + if(checksum != checksum32) { User::Leave(KErrCorrupt); } @@ -503,34 +624,30 @@ */ void FunctionalTest() { - TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4002 Backup: functional test ")); - - CSqlBackupClient* backupClient = NULL; - TRAPD(err, backupClient = CSqlBackupClient::NewL(TheTestHarness)); + CSqlBurCallback* backupClient = NULL; + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface)); TEST(backupClient != NULL); //////////////////////////////////////// - - const TDriveNumber KDrive = EDriveC; //Virtual functions - with default implementation - (void)backupClient->GetExpectedDataSize(KDrive); + (void)backupClient->GetExpectedDataSize(KTestDrive); - (void)backupClient->GetDataChecksum(KDrive); + (void)backupClient->GetDataChecksum(KTestDrive); TBool finished = EFalse; TPtr8 ptr(0, 0, 0); - TRAP(err, backupClient->GetSnapshotDataL(KDrive, ptr, finished)); + TRAP(err, backupClient->GetSnapshotDataL(KTestDrive, ptr, finished)); TEST2(err, KErrNotSupported); - TRAP(err, backupClient->InitialiseGetBackupDataL(KDrive)); + TRAP(err, backupClient->InitialiseGetBackupDataL(KTestDrive)); TEST2(err, KErrNotSupported); - TRAP(err, backupClient->InitialiseRestoreBaseDataL(KDrive)); + TRAP(err, backupClient->InitialiseRestoreBaseDataL(KTestDrive)); TEST2(err, KErrNotSupported); - TRAP(err, backupClient->InitialiseRestoreIncrementDataL(KDrive)); + TRAP(err, backupClient->InitialiseRestoreIncrementDataL(KTestDrive)); TEST2(err, KErrNotSupported); TPtrC8 ptr2(KNullDesC8); @@ -540,7 +657,7 @@ TRAP(err, backupClient->AllSnapshotsSuppliedL()); TEST2(err, KErrNone); - TRAP(err, backupClient->ReceiveSnapshotDataL(KDrive, ptr2, finished)); + TRAP(err, backupClient->ReceiveSnapshotDataL(KTestDrive, ptr2, finished)); TEST2(err, KErrNotSupported); backupClient->TerminateMultiStageOperation(); @@ -548,45 +665,47 @@ //////////////////////////////////////// TInt bytesStored = 0; - TRAP(err, bytesStored = TestBackupL(*backupClient, TheTestHarness->Fs())); + TRAP(err, bytesStored = TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KClientUid, KTestDrive)); TEST2(err, KErrNone); TheTest.Next(_L("Archive integrity test")); - TRAP(err, TestArchiveIntegrityL(*backupClient, TheTestHarness->Fs())); + TRAP(err, TestArchiveIntegrityL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KClientUid)); TEST2(err, KErrNone); delete backupClient; TheTest.Next(_L("Restore: functional test")); - CSqlBackupClient* restoreClient = NULL; - TRAP(err, restoreClient = CSqlBackupClient::NewL(TheTestHarness)); + CSqlBurCallback* restoreClient = NULL; + TRAP(err, restoreClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface)); TEST(restoreClient != NULL); TInt bytesRestored = 0; - TRAP(err, bytesRestored = TestRestoreL(*restoreClient, TheTestHarness->Fs())); + TRAP(err, bytesRestored = TestRestoreL(*restoreClient, TheSqlSrvTestBurInterface->Fs(), KClientUid, KTestDrive)); TEST2(err, KErrNone); TEST(bytesRestored == bytesStored); delete restoreClient; - CompareDbContentWithBuf(TheTestHarness->Fs()); + CompareDbContentWithBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid); } -TInt DoBackupL() +TInt DoBackupL(TDriveNumber aDrive, TSecureId aUid) { - CSqlBackupClient* backupClient = CSqlBackupClient::NewLC(TheTestHarness); - TInt bytesStored = TestBackupL(*backupClient, TheTestHarness->Fs()); + CSqlBurCallback* backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface); + CleanupStack::PushL(backupClient); + TInt bytesStored = TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), aUid, aDrive); CleanupStack::PopAndDestroy(backupClient); return bytesStored; } -TInt DoRestoreL() +TInt DoRestoreL(TDriveNumber aDrive, TSecureId aUid) { - CSqlBackupClient* restoreClient = CSqlBackupClient::NewLC(TheTestHarness); - TInt bytesRestored = TestRestoreL(*restoreClient, TheTestHarness->Fs()); + CSqlBurCallback* restoreClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface); + CleanupStack::PushL(restoreClient); + TInt bytesRestored = TestRestoreL(*restoreClient, TheSqlSrvTestBurInterface->Fs(), aUid, aDrive); CleanupStack::PopAndDestroy(restoreClient); return bytesRestored; } @@ -606,7 +725,6 @@ void OomTest() { /////////////////////////////////////////////////////////////////////////////// - TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4003 Backup: OOM test ")); TInt err = KErrNoMemory; TInt bytesStored = 0; TInt count = 0; @@ -619,7 +737,7 @@ User::__DbgMarkStart(RHeap::EUser); User::__DbgSetAllocFail(RHeap::EUser,RHeap::EFailNext, count); - TRAP(err, bytesStored = DoBackupL()); + TRAP(err, bytesStored = DoBackupL(KTestDrive, KClientUid)); User::__DbgMarkEnd(RHeap::EUser, 0); TInt endProcessHandleCount; @@ -645,7 +763,7 @@ User::__DbgMarkStart(RHeap::EUser); User::__DbgSetAllocFail(RHeap::EUser,RHeap::EFailNext, count); - TRAP(err, bytesRestored = DoRestoreL()); + TRAP(err, bytesRestored = DoRestoreL(KTestDrive, KClientUid)); User::__DbgMarkEnd(RHeap::EUser, 0); TInt endProcessHandleCount; @@ -659,9 +777,9 @@ User::__DbgSetAllocFail(RHeap::EUser, RAllocator::ENone, 0); TheTest.Printf(_L("OOM restore test succeeded at heap failure rate of %d\r\n"), count); - TEST(bytesStored == bytesRestored); + TEST2(bytesStored, bytesRestored); - CompareDbContentWithBuf(TheTestHarness->Fs()); + CompareDbContentWithBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid); } /** @@ -678,8 +796,6 @@ */ void FunctionalTest2() { - TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4143 Backup&Restore: functional test 2")); - TTime now; now.UniversalTime(); TInt64 seed = now.Int64(); @@ -700,32 +816,32 @@ for(TInt i=0;iFs(), dataChunks[i])); + TRAP(err, bytesStored = TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KClientUid, KTestDrive, dataChunks[i])); TEST2(err, KErrNone); - TRAP(err, TestArchiveIntegrityL(*backupClient, TheTestHarness->Fs())); + TRAP(err, TestArchiveIntegrityL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KClientUid)); TEST2(err, KErrNone); delete backupClient; - CSqlBackupClient* restoreClient = NULL; - TRAP(err, restoreClient = CSqlBackupClient::NewL(TheTestHarness)); + CSqlBurCallback* restoreClient = NULL; + TRAP(err, restoreClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface)); TEST(restoreClient != NULL); TInt bytesRestored = 0; - TRAP(err, bytesRestored = TestRestoreL(*restoreClient, TheTestHarness->Fs(), dataChunks[i])); + TRAP(err, bytesRestored = TestRestoreL(*restoreClient, TheSqlSrvTestBurInterface->Fs(), KClientUid, KTestDrive, dataChunks[i])); TEST2(err, KErrNone); TEST(bytesRestored == bytesStored); delete restoreClient; - CompareDbContentWithBuf(TheTestHarness->Fs()); + CompareDbContentWithBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid); } } @@ -743,24 +859,22 @@ */ void LegacyFileFormatTest() { - TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4144 Backup&Restore: legacy file format test")); - //KBackupFile2 is a database backup file with header version 0. - (void)TheTestHarness->Fs().Delete(KBackupFile2); - TInt rc = BaflUtils::CopyFile(TheTestHarness->Fs(), KBackupFile2Z, KBackupFile2); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KBackupFile2); + TInt rc = BaflUtils::CopyFile(TheSqlSrvTestBurInterface->Fs(), KBackupFile2Z, KBackupFile2); TEST2(rc, KErrNone); - (void)TheTestHarness->Fs().SetAtt(KBackupFile2, 0, KEntryAttReadOnly); + (void)TheSqlSrvTestBurInterface->Fs().SetAtt(KBackupFile2, 0, KEntryAttReadOnly); //Restore the databases from KBackupFile2. - CSqlBackupClient* restoreClient = NULL; - TRAP(rc, restoreClient = CSqlBackupClient::NewL(TheTestHarness)); + CSqlBurCallback* restoreClient = NULL; + TRAP(rc, restoreClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface)); TEST(restoreClient != NULL); RFile file; - rc = file.Open(TheTestHarness->Fs(), KBackupFile2, EFileRead | EFileShareExclusive); + rc = file.Open(TheSqlSrvTestBurInterface->Fs(), KBackupFile2, EFileRead | EFileShareExclusive); TEST2(rc, KErrNone); - TRAP(rc, restoreClient->InitialiseRestoreProxyBaseDataL(KClientUid, EDriveC)); + TRAP(rc, restoreClient->InitialiseRestoreProxyBaseDataL(KClientUid, KTestDrive)); TEST2(rc, KErrNone); TBuf8 buf; @@ -784,7 +898,7 @@ file.Close(); - restoreClient->RestoreComplete(EDriveC); + restoreClient->RestoreComplete(KTestDrive); TEST(finishedFlag); @@ -825,7 +939,7 @@ TEST2(rc, KSqlAtEnd); db.Close(); - (void)TheTestHarness->Fs().Delete(KBackupFile2); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KBackupFile2); } /** @@ -840,13 +954,11 @@ */ void EmptyBackupFileListTest() { - TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4192 Backup&Restore: empty backup file list")); - - CSqlBackupClient* backupClient = NULL; - TRAPD(err, backupClient = CSqlBackupClient::NewL(TheTestHarness)); + CSqlBurCallback* backupClient = NULL; + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface)); TEST(backupClient != NULL); - TRAP(err, backupClient->InitialiseGetProxyBackupDataL(KNullUid, EDriveC)); + TRAP(err, backupClient->InitialiseGetProxyBackupDataL(KNullUid, KTestDrive)); TEST2(err, KErrNone); TBuf8<100> buf; @@ -872,11 +984,9 @@ */ void BackupRestoreFileIoErrTest() { - TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4193 Backup: File I/O error simulation test")); - //Make sure that the database content, just before the backup, will be copied to the test biffers. //The buffers will be used during the restore testing for verification of the database content. - StoreDbContentToBuf(TheTestHarness->Fs()); + StoreDbContentToBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid); for(TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError) { @@ -888,9 +998,9 @@ for(;errFs().SetErrorCondition(fsError, it_cnt1); - TRAP(err, bytesStored = DoBackupL()); - (void)TheTestHarness->Fs().SetErrorCondition(KErrNone); + (void)TheSqlSrvTestBurInterface->Fs().SetErrorCondition(fsError, it_cnt1); + TRAP(err, bytesStored = DoBackupL(KTestDrive, KClientUid)); + (void)TheSqlSrvTestBurInterface->Fs().SetErrorCondition(KErrNone); __UHEAP_MARKEND; } TEST2(err, KErrNone); @@ -901,40 +1011,878 @@ for(;errFs().SetErrorCondition(fsError, it_cnt2); - TRAP(err, bytesRestored = DoRestoreL()); - (void)TheTestHarness->Fs().SetErrorCondition(KErrNone); + (void)TheSqlSrvTestBurInterface->Fs().SetErrorCondition(fsError, it_cnt2); + TRAP(err, bytesRestored = DoRestoreL(KTestDrive, KClientUid)); + (void)TheSqlSrvTestBurInterface->Fs().SetErrorCondition(KErrNone); __UHEAP_MARKEND; } TEST2(err, KErrNone); TEST2(bytesStored, bytesRestored); - CompareDbContentWithBuf(TheTestHarness->Fs()); + CompareDbContentWithBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid); TheTest.Printf(_L("Backup&Restore file I/O error simulation test succeeded at backup iteration %d and restore itreration %d\r\n"), it_cnt1 - 1, it_cnt2 - 1); } } +/** +@SYMTestCaseID PDS-SQL-UT-4225 +@SYMTestCaseDesc SQL Backup - zero size file backup. + The test executes a backup on a file with zero size. +@SYMTestActions SQL Backup - zero size file backup. +@SYMTestExpectedResults Test must not fail +@SYMTestPriority High +*/ +void BackupZeroSizeFileTest() + { + CSqlBurCallback* backupClient = NULL; + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface)); + TEST2(err, KErrNone); + TEST(backupClient != NULL); + // + (void)TheSqlSrvTestBurInterface->Fs().Delete(KZeroSizeFile); + RFile file; + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KZeroSizeFile, EFileRead | EFileWrite); + TEST2(err, KErrNone); + file.Close(); + // + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KZeroFileSizeUid, KTestDrive)); + TEST2(err, KErrNone); + //Write something to the file + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KZeroSizeFile, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData, "123456787989"); + err = file.Write(KData); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Do the restore. After the restore the file size should be 0. + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KZeroFileSizeUid, KTestDrive)); + TEST2(err, KErrNone); + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KZeroSizeFile, EFileRead | EFileWrite); + TEST2(err, KErrNone); + TInt size; + err = file.Size(size); + TEST2(err, KErrNone); + file.Close(); + TEST2(size, 0); + //Write something to the file + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KZeroSizeFile, EFileRead | EFileWrite); + TEST2(err, KErrNone); + err = file.Write(KData); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Call RestoreBaseDataSectionL() with 0 data in the input buffer and finished flag: false. + TRAP(err, backupClient->InitialiseRestoreProxyBaseDataL(KZeroFileSizeUid, KTestDrive)); + TEST2(err, KErrNone); + TPtrC8 zeroBuf; + TRAP(err, backupClient->RestoreBaseDataSectionL(zeroBuf, EFalse)); + TEST2(err, KErrNone); + //No restore in this case, + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KZeroSizeFile, EFileRead | EFileWrite); + TEST2(err, KErrNone); + err = file.Size(size); + TEST2(err, KErrNone); + file.Close(); + TEST(size > 0); + //Call RestoreBaseDataSectionL() with 0 data in the input buffer and finished flag: true. + TRAP(err, backupClient->InitialiseRestoreProxyBaseDataL(KZeroFileSizeUid, KTestDrive)); + TEST2(err, KErrNone); + TRAP(err, backupClient->RestoreBaseDataSectionL(zeroBuf, ETrue)); + TEST2(err, KErrNone); + //No restore in this case, + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KZeroSizeFile, EFileRead | EFileWrite); + TEST2(err, KErrNone); + err = file.Size(size); + TEST2(err, KErrNone); + file.Close(); + TEST(size > 0); + // + (void)TheSqlSrvTestBurInterface->Fs().Delete(KZeroSizeFile); + delete backupClient; + } + +/** +@SYMTestCaseID PDS-SQL-UT-4226 +@SYMTestCaseDesc SQL Restore - corrupted archive 1. + The test does a backup of a file with a non-zero size. + The the test modifies the archive, simulating a corruption. + The the test performs a restore from the archive. The corruption + should be detected and reported by SQL B&R code. +@SYMTestActions SQL Restore - corrupted archive 1. +@SYMTestExpectedResults Test must not fail +@SYMTestPriority High +*/ +void CorruptedArchiveTest1() + { + CSqlBurCallback* backupClient = NULL; + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface)); + TEST2(err, KErrNone); + TEST(backupClient != NULL); + //Create the test file that will be sent for backup + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1); + RFile file; + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData1, "123456787989"); + err = file.Write(KData1); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Backup the file + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive)); + TEST2(err, KErrNone); + //Modify the file, which was sent for backup + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData2, "ABCDEFGH"); + err = file.Write(KData2); + TEST2(err, KErrNone); + err = file.SetSize(KData2().Length()); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Corrupt the archive + TFileName backupFileName; + backupFileName.Copy(KBackupFileTemplate); + backupFileName.Append((static_cast (KTestClientUid1)).Name()); + err = file.Open(TheSqlSrvTestBurInterface->Fs(), backupFileName, EFileRead | EFileWrite); + TEST2(err, KErrNone); + TInt pos = -3; + err = file.Seek(ESeekEnd, pos); + TEST2(err, KErrNone); + _LIT8(KData3, "ERR"); + err = file.Write(KData3); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Try to restore the archive + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive)); + TEST2(err, KErrCorrupt); + //Check that the file really has not been restored + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite); + TEST2(err, KErrNone); + TBuf8<50> data; + err = file.Read(data); + TEST2(err, KErrNone); + file.Close(); + TEST(data == KData2); + // + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1); + delete backupClient; + } + +/** +@SYMTestCaseID PDS-SQL-UT-4227 +@SYMTestCaseDesc SQL Restore - corrupted archive 2. + The test does a backup of a file with a non-zero size. + Then the test modifies the archive, byte after byte each step, + simulating a corruption. + The the test performs a restore from the archive. The corruption + should be detected and reported by SQL B&R code. +@SYMTestActions SQL Restore - corrupted archive 2. +@SYMTestExpectedResults Test must not fail +@SYMTestPriority High +*/ +void CorruptedArchiveTest2() + { + CSqlBurCallback* backupClient = NULL; + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface)); + TEST2(err, KErrNone); + TEST(backupClient != NULL); + //Create the test file that will be sent for backup + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1); + RFile file; + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData1, "123456787989"); + err = file.Write(KData1); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Backup the file + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive)); + TEST2(err, KErrNone); + //Modify the file, which was sent for backup + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData2, "ABCDEFGH"); + err = file.Write(KData2); + TEST2(err, KErrNone); + err = file.SetSize(KData2().Length()); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Make a copy of the modified file + CFileMan* fm = NULL; + TRAP(err, fm = CFileMan::NewL(TheSqlSrvTestBurInterface->Fs())); + TEST2(err, KErrNone); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1Bak); + err = fm->Copy(KTestFile1, KTestFile1Bak); + TEST2(err, KErrNone); + //Get the archive size + TFileName backupFileName; + backupFileName.Copy(KBackupFileTemplate); + backupFileName.Append((static_cast (KTestClientUid1)).Name()); + err = file.Open(TheSqlSrvTestBurInterface->Fs(), backupFileName, EFileRead | EFileWrite); + TEST2(err, KErrNone); + TInt size = 0; + err = file.Size(size); + TEST2(err, KErrNone); + file.Close(); + //Save a copy of the archive + (void)TheSqlSrvTestBurInterface->Fs().Delete(KBackupCopy); + err = fm->Copy(backupFileName, KBackupCopy); + TEST2(err, KErrNone); + //On each iteration step: corrupt the archive and try to do a restore from it. + for(TInt i=0;iFs(), backupFileName, EFileRead | EFileWrite); + TEST2(err, KErrNone); + TInt pos = i; + err = file.Seek(ESeekStart, pos); + TEST2(err, KErrNone); + TBuf8<1> byte; + err = file.Read(byte); + TEST2(err, KErrNone); + ++byte[0]; + err = file.Seek(ESeekStart, pos); + TEST2(err, KErrNone); + err = file.Write(byte); + TEST2(err, KErrNone); + if(i == (size - 1) && (size & 0x01) == 0) + {//Make the file size an odd number, just to test.... + err = file.Write(byte); + TEST2(err, KErrNone); + } + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Restore + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive)); + TheTest.Printf(_L("Iteration %d, err=%d\r\n"), i, err); + if(err == KErrNone) + { + //Delete the restored file. The reason that the restore didn't fail is because only the file data is + //protected with checksum. The restore file header - not. The restore completed, the data was restored + //to a file with different name. Or even to a file with the same name. Delete created file(s). + (void)fm->Delete(KTestDeleteMask1); + (void)fm->Delete(KTestDeleteMask2); + } + else + { + //The restore completed with an error. The file content is preserved. + //Check that the file content is the same. + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite); + TEST2(err, KErrNone); + TBuf8<50> data; + err = file.Read(data); + TEST2(err, KErrNone); + file.Close(); + TEST(data == KData2); + } + //Restore the file from the backup copy + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1); + err = fm->Copy(KTestFile1Bak, KTestFile1); + TEST2(err, KErrNone); + //Restore the archive from the good copy. + (void)TheSqlSrvTestBurInterface->Fs().Delete(backupFileName); + err = fm->Copy(KBackupCopy, backupFileName); + TEST2(err, KErrNone); + } + // + delete fm; + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1Bak); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KBackupCopy); + delete backupClient; + } + +/** +@SYMTestCaseID PDS-SQL-UT-4228 +@SYMTestCaseDesc SQL Backup&Restore on a drive different than KTestDrive (C: by default). + The test creates one database on KTestDrive and another database + with the same name on a drive different than KTestDrive. + Then the test backups the "not KTestDrive" drive and restores + the data after that. The test verifies that the backup&restore + really impacts only the other drive, not KTestDrive. +@SYMTestActions SQL Backup&Restore on a drive different than KTestDrive (C: by default). +@SYMTestExpectedResults Test must not fail +@SYMTestPriority High +*/ +void DbDriveTest() + { + CSqlBurCallback* backupClient = NULL; + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface)); + TEST2(err, KErrNone); + TEST(backupClient != NULL); + // + TDriveUnit driveUnitDefault(KTestDrive); + TDriveName driveNameDefault = driveUnitDefault.Name(); + //Find a r/w drive, different than KTestDrive + TInt drive = EDriveA; + for(;drive<=EDriveZ;++drive) + { + if(drive == KTestDrive) + { + continue; + } + TDriveInfo driveInfo; + err = TheSqlSrvTestBurInterface->Fs().Drive(driveInfo, drive); + if(err != KErrNone) + { + continue; + } + if(driveInfo.iDriveAtt & KDriveAttRom) + { + continue; + } + // + TDriveUnit driveUnit(drive); + TDriveName driveName = driveUnit.Name(); + // + TVolumeInfo vinfo; + err = TheSqlSrvTestBurInterface->Fs().Volume(vinfo, drive); + if(err != KErrNone) + { + TheTest.Printf(_L("Drive %S, RFs::Volume() err=%d\r\n"), &driveName, err); + continue; + } + //R/W drive found. + TheTest.Printf(_L("Test drive: %S\r\n"), &driveName); + TParse parse; + err = parse.Set(KTestFile2, &driveName, 0); + TEST2(err, KErrNone); + //Create the test file that will be sent for backup + TPtrC fname1(parse.FullName()); + TheTest.Printf(_L("Test file 1: %S\r\n"), &fname1); + err = TheSqlSrvTestBurInterface->Fs().MkDirAll(parse.FullName()); + TEST(err == KErrNone || err == KErrAlreadyExists); + (void)TheSqlSrvTestBurInterface->Fs().Delete(parse.FullName()); + RFile file; + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), parse.FullName(), EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData1, "123456787989"); + err = file.Write(KData1); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Create a test file with the same name on drive KTestDrive + err = parse.Set(KTestFile2, &driveNameDefault, 0); + TEST2(err, KErrNone); + TPtrC fname2(parse.FullName()); + TheTest.Printf(_L("Test file 2: %S\r\n"), &fname2); + (void)TheSqlSrvTestBurInterface->Fs().Delete(parse.FullName()); + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), parse.FullName(), EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData2, "ABCDEFG"); + err = file.Write(KData2); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Do the backup on "drive" + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid2, (TDriveNumber)drive)); + TEST2(err, KErrNone); + //Modify the file that was sent for backup + err = parse.Set(KTestFile2, &driveName, 0); + TEST2(err, KErrNone); + err = file.Open(TheSqlSrvTestBurInterface->Fs(), parse.FullName(), EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData3, "ABCDEFGHYYYYYY"); + err = file.Write(KData3); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Do the restore on "drive" + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid2, (TDriveNumber)drive)); + TEST2(err, KErrNone); + //Verify the content of the restored file + err = parse.Set(KTestFile2, &driveName, 0); + TEST2(err, KErrNone); + err = file.Open(TheSqlSrvTestBurInterface->Fs(), parse.FullName(), EFileRead | EFileWrite); + TEST2(err, KErrNone); + TBuf8<50> data; + err = file.Read(data); + TEST2(err, KErrNone); + file.Close(); + TEST(data == KData1); + //Verify the content of the file on drive KTestDrive. It should be the same as before the backup&restore. + err = parse.Set(KTestFile2, &driveNameDefault, 0); + TEST2(err, KErrNone); + err = file.Open(TheSqlSrvTestBurInterface->Fs(), parse.FullName(), EFileRead | EFileWrite); + TEST2(err, KErrNone); + err = file.Read(data); + TEST2(err, KErrNone); + file.Close(); + TEST(data == KData2); + //Cleanup + err = parse.Set(KTestFile2, &driveNameDefault, 0); + TEST2(err, KErrNone); + (void)TheSqlSrvTestBurInterface->Fs().Delete(parse.FullName()); + err = parse.Set(KTestFile2, &driveName, 0); + TEST2(err, KErrNone); + (void)TheSqlSrvTestBurInterface->Fs().Delete(parse.FullName()); + break; + } + delete backupClient; + if(drive > EDriveZ) + { + TheTest.Printf(_L("No R/W drive has been found, different than %S\r\n"), &driveNameDefault); + } + } + +/** +@SYMTestCaseID PDS-SQL-UT-4229 +@SYMTestCaseDesc SQL Backup&Restore with locked file. + The test creates two test files on the same drive and with the same uid. + Then the test backups the databases. After the backup the test simulates that + the first file is "in use". Then the test performs a restore. + The expected result: the locked file is not restored but the other file is restored. +@SYMTestActions SQL Backup&Restore with locked file. +@SYMTestExpectedResults Test must not fail +@SYMTestPriority High +*/ +void LockFileTest() + { + CSqlBurCallback* backupClient = NULL; + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface)); + TEST2(err, KErrNone); + TEST(backupClient != NULL); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile3); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile4); + //Create the files. File 1. + RFile file; + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile3, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData1, "123456787989"); + err = file.Write(KData1); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //...file 2 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile4, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData2, "ABCDEF"); + err = file.Write(KData2); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Backup + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid3, KTestDrive)); + TEST2(err, KErrNone); + //Modify the files. Keep the first file opened. + RFile file1; + err = file1.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile3, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData3, "YYYYYQQQQQQQQQQQ"); + err = file1.Write(KData3); + TEST2(err, KErrNone); + err = file1.Flush(); + TEST2(err, KErrNone); + //...file 2 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile4, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData4, "5545495444j32322332234223432"); + err = file.Write(KData4); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Restore. The reported error should be KErrInUse. + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid3, KTestDrive)); + TEST2(err, KErrInUse); + //Close file 1 and check the content. It should be the same as after the backup + file1.Close(); + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile3, EFileRead | EFileWrite); + TEST2(err, KErrNone); + TBuf8<50> data; + err = file.Read(data); + TEST2(err, KErrNone); + file.Close(); + TEST(data == KData3); + //File2: check the content. It should be the same as before the backup + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile4, EFileRead | EFileWrite); + TEST2(err, KErrNone); + err = file.Read(data); + TEST2(err, KErrNone); + file.Close(); + TEST(data == KData2); + // + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile4); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile3); + delete backupClient; + } + +/** +@SYMTestCaseID PDS-SQL-UT-4230 +@SYMTestCaseDesc SQL Backup&Restore with locked file - test 2. + The test creates two test files on the same drive and with different uids. + Then the test backups the databases. After the backup the test simulates that + the first file is "in use". Then the test performs a restore. + The expected result: the locked file is not restored but the other file is restored. +@SYMTestActions SQL Backup&Restore with locked file - test 2. +@SYMTestExpectedResults Test must not fail +@SYMTestPriority High +*/ +void LockFileTest2() + { + CSqlBurCallback* backupClient = NULL; + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface)); + TEST2(err, KErrNone); + TEST(backupClient != NULL); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);//KTestClientUid1 used + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile4);//KTestClientUid3 used + //Create the files. File 1. + RFile file; + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData1, "123456787989"); + err = file.Write(KData1); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //...file 2 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile4, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData2, "ABCDEF"); + err = file.Write(KData2); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Backup + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive)); + TEST2(err, KErrNone); + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid3, KTestDrive)); + TEST2(err, KErrNone); + //Modify the files. Keep the first file opened. + RFile file1; + err = file1.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData3, "YYYYYQQQQQQQQQQQ"); + err = file1.Write(KData3); + TEST2(err, KErrNone); + err = file1.Flush(); + TEST2(err, KErrNone); + //...file 2 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile4, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData4, "5545495444j32322332234223432"); + err = file.Write(KData4); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Restore the first file. The reported error should be KErrInUse. + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive)); + TEST2(err, KErrInUse); + //Restore the second file. The reported error should be KErrNone. + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid3, KTestDrive)); + TEST2(err, KErrNone); + //Close file 1 and check the content. It should be the same as after the backup + file1.Close(); + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite); + TEST2(err, KErrNone); + TBuf8<50> data; + err = file.Read(data); + TEST2(err, KErrNone); + file.Close(); + TEST(data == KData3); + //File2: check the content. It should be the same as before the backup + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile4, EFileRead | EFileWrite); + TEST2(err, KErrNone); + err = file.Read(data); + TEST2(err, KErrNone); + file.Close(); + TEST(data == KData2); + // + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile4); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1); + delete backupClient; + } + +CDir* GetPrivateDirContent(TDriveNumber aDrive) + { + TDriveUnit driveUnit(aDrive); + TDriveName driveName = driveUnit.Name(); + TFileName path; + path.Copy(driveName); + path.Append(KPrivateDir); + _LIT(KMatchAllDbFiles, "*"); + path.Append(KMatchAllDbFiles); + //Do the search + CDir* fileNameCol = NULL; + TInt err = TheSqlSrvTestBurInterface->Fs().GetDir(path, KEntryAttNormal, ESortByName, fileNameCol); + TEST2(err, KErrNone); + return fileNameCol; + } + +/** +@SYMTestCaseID PDS-SQL-UT-4231 +@SYMTestCaseDesc SQL Backup&Restore - directory content test. + The test stores into an array information regarding all files in + SQL private datacage. Then the test backups one of the files and modifies + the file after that. Then the test does a restore. Expected result - the only + modifed file should be the file which was sent for backup. +@SYMTestActions SQL Backup&Restore - directory content test. +@SYMTestExpectedResults Test must not fail +@SYMTestPriority High +*/ +void DirectoryContentTest() + { + CSqlBurCallback* backupClient = NULL; + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface)); + TEST2(err, KErrNone); + TEST(backupClient != NULL); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);//KTestClientUid1 used + //Create the file + RFile file; + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData1, "123456787989"); + err = file.Write(KData1); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Store file entries into an array + CDir* dirBeforeBackup = GetPrivateDirContent(KTestDrive); + //Backup + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive)); + TEST2(err, KErrNone); + //Check dir content + CDir* dirAfterBackup = GetPrivateDirContent(KTestDrive); + TEST2(dirBeforeBackup->Count(), dirAfterBackup->Count()); + for(TInt i=0;iCount();++i) + { + const TEntry& entry1 = (*dirBeforeBackup)[i]; + const TEntry& entry2 = (*dirAfterBackup)[i]; + TheTest.Printf(_L("Entry1=%S, Entry2=%S\r\n"), &entry1.iName, &entry2.iName); + TBool rc = entry1.iAtt == entry2.iAtt; + TEST(rc); + rc = entry1.iSize == entry2.iSize; + TEST(rc); + rc = entry1.iModified == entry2.iModified; + TEST(rc); + rc = entry1.iType == entry2.iType; + TEST(rc); + rc = entry1.iName == entry2.iName; + TEST(rc); + } + delete dirAfterBackup; + //Modify the file + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite); + TEST2(err, KErrNone); + _LIT8(KData2, "ABCDEF"); + err = file.Write(KData2); + TEST2(err, KErrNone); + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Restore + User::After(2000000);//To force a change in the file time stamp (the restored file time stamp). + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive)); + TEST2(err, KErrNone); + //Check dir content + CDir* dirAfterRestore = GetPrivateDirContent(KTestDrive); + TEST2(dirBeforeBackup->Count(), dirAfterRestore->Count()); + for(TInt i=0;iCount();++i) + { + const TEntry& entry1 = (*dirBeforeBackup)[i]; + const TEntry& entry2 = (*dirAfterRestore)[i]; + TheTest.Printf(_L("Entry1=%S, Entry2=%S\r\n"), &entry1.iName, &entry2.iName); + TBool rc = entry1.iAtt == entry2.iAtt; + TEST(rc); + rc = entry1.iSize == entry2.iSize; + TEST(rc); + if(entry1.iName.FindF(KTestFile1NameOnly) >= 0) + { + rc = entry1.iModified != entry2.iModified; + } + else + { + rc = entry1.iModified == entry2.iModified; + } + TEST(rc); + rc = entry1.iType == entry2.iType; + TEST(rc); + rc = entry1.iName == entry2.iName; + TEST(rc); + } + delete dirAfterRestore; + // + delete dirBeforeBackup; + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1); + delete backupClient; + } + +/** +@SYMTestCaseID PDS-SQL-UT-4232 +@SYMTestCaseDesc SQL Backup&Restore - large file test. + Backup and restore with a file with size bigger than 1 Mb. +@SYMTestActions SQL Backup&Restore - large file test. +@SYMTestExpectedResults Test must not fail +@SYMTestPriority High +*/ +void LargeFileTest() + { + CSqlBurCallback* backupClient = NULL; + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface)); + TEST2(err, KErrNone); + TEST(backupClient != NULL); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);//KTestClientUid1 used + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile2);//KTestClientUid2 used + //Allocate buffer for the data + const TInt KDataBufSize = 100000; + HBufC8* dataBuf = HBufC8::New(KDataBufSize); + TEST(dataBuf != NULL); + TPtr8 dataPtr = dataBuf->Des(); + //Create file 1 + const TInt KFileSize1 = 1201345; + RFile file; + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite); + TEST2(err, KErrNone); + dataPtr.SetLength(dataPtr.MaxLength()); + const TChar KChar1(0x5A); + dataPtr.Fill(KChar1); + TInt len = KFileSize1; + while(len > 0) + { + TInt blockSize = Min(len, dataPtr.MaxLength()); + err = file.Write(dataPtr, blockSize); + TEST2(err, KErrNone); + len -= blockSize; + } + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Create file 2 + const TInt KFileSize2 = 1387651; + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile2, EFileRead | EFileWrite); + TEST2(err, KErrNone); + dataPtr.SetLength(dataPtr.MaxLength()); + const TChar KChar2(0xD5); + dataPtr.Fill(KChar2); + len = KFileSize2; + while(len > 0) + { + TInt blockSize = Min(len, dataPtr.MaxLength()); + err = file.Write(dataPtr, blockSize); + TEST2(err, KErrNone); + len -= blockSize; + } + err = file.Flush(); + TEST2(err, KErrNone); + file.Close(); + //Backup + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive)); + TEST2(err, KErrNone); + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid2, KTestDrive)); + TEST2(err, KErrNone); + //Delete the files + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile2); + //Restore + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive)); + TEST2(err, KErrNone); + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid2, KTestDrive)); + TEST2(err, KErrNone); + //Check restored files content + const TPtrC KFileNames[] = {KTestFile1(), KTestFile2()}; + const TInt KFileSizes[] = {KFileSize1, KFileSize2}; + const TChar KSymbols[] = {KChar1, KChar2}; + for(TInt i=0;i<(sizeof(KFileNames)/sizeof(KFileNames[i]));++i) + { + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KFileNames[i], EFileRead); + TEST2(err, KErrNone); + len = 0; + err = file.Size(len); + TEST2(err, KErrNone); + TEST2(len, KFileSizes[i]); + while(len > 0) + { + TInt blockSize = Min(len, dataPtr.MaxLength()); + err = file.Read(dataPtr, blockSize); + TEST2(err, KErrNone); + len -= blockSize; + for(TInt j=0;jFs().Delete(KTestFile2); + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1); + delete backupClient; + } void DoMain() { TestEnvCreate(); TheTest.Start(_L("Store db content to memory buffer")); - StoreDbContentToBuf(TheTestHarness->Fs()); + StoreDbContentToBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid); + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4002 Backup: functional test ")); FunctionalTest(); + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4003 Backup: OOM test ")); OomTest(); + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4143 Backup&Restore: functional test 2")); FunctionalTest2(); + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4144 Backup&Restore: legacy file format test")); LegacyFileFormatTest(); + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4192 Backup&Restore: empty backup file list")); EmptyBackupFileListTest(); + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4193 Backup: File I/O error simulation test")); BackupRestoreFileIoErrTest(); + + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4225 Zero size file - backup test")); + BackupZeroSizeFileTest(); + + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4226 Restore test - corrupted archive 1")); + CorruptedArchiveTest1(); + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4227 Restore test - corrupted archive 2")); + CorruptedArchiveTest2(); + + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4228 Backup&Restore test on a drive different than KTestDrive (C: by default)")); + DbDriveTest(); + + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4229 Backup&Restore test with locked file")); + LockFileTest(); + + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4230 Backup&Restore test with locked file 2")); + LockFileTest2(); + + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4231 Backup&Restore - directory content test")); + DirectoryContentTest(); + + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4232 Backup&Restore - large file test")); + LargeFileTest(); + TestEnvDestroy(); } @@ -943,7 +1891,7 @@ TheTest.Title(); CTrapCleanup* tc = CTrapCleanup::New(); - TEST(tc != NULL); + TheTest(tc != NULL); __UHEAP_MARK;