1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqlbur.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1909 @@
1.4 +// Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include <e32test.h>
1.20 +#include <bautils.h>
1.21 +#include <sqldb.h>
1.22 +#include <e32math.h>
1.23 +
1.24 +#include "SqlBur.h"
1.25 +#include "t_sqlbur.h"
1.26 +
1.27 +///////////////////////////////////////////////////////////////////////////////////////
1.28 +
1.29 +RTest TheTest(_L("SQL Backup and Restore Test"));
1.30 +
1.31 +_LIT(KPrivateDir, "\\private\\10281e17\\");
1.32 +
1.33 +//Don't forget to update DeleteBackupFiles() implementation if a new uid is added
1.34 +const TSecureId KClientUid = 0x21212122; // the data owner's UID
1.35 +const TSecureId KZeroFileSizeUid = 0xFFFF4321;
1.36 +const TSecureId KTestClientUid1 = 0xFFFF4322;
1.37 +const TSecureId KTestClientUid2 = 0xFFFF4323;
1.38 +const TSecureId KTestClientUid3 = 0xFFFF4324;
1.39 +
1.40 +_LIT(KBackupDir, "C:\\TEST\\");
1.41 +_LIT(KBackupFileTemplate, "C:\\TEST\\Backup.bak");
1.42 +_LIT(KBackupCopy, "C:\\TEST\\Backup2.bak");
1.43 +_LIT(KBackupFile2Z, "Z:\\TEST\\t_sqlbur_backup_ver0.bak");
1.44 +_LIT(KBackupFile2, "C:\\TEST\\t_sqlbur_backup_ver0.bak");
1.45 +
1.46 +_LIT(KZeroSizeFile, "C:\\private\\10281e17\\[FFFF4321]t_sqlbur_zero.db");
1.47 +_LIT(KTestFile1, "C:\\private\\10281e17\\[FFFF4322]t_sqlbur_test1.db");
1.48 +_LIT(KTestFile1NameOnly, "[FFFF4322]t_sqlbur_test1.db");
1.49 +_LIT(KTestFile1Bak, "C:\\private\\10281e17\\bak[FFFF4322]t_sqlbur_test1.db.bak");
1.50 +_LIT(KTestDeleteMask1, "C:\\private\\10281e17\\[FFFF4322]*");
1.51 +_LIT(KTestDeleteMask2, "*bur_test1.db");
1.52 +_LIT(KTestFile2, "\\private\\10281e17\\[FFFF4323]t_sqlbur_test2.db");
1.53 +_LIT(KTestFile3, "c:\\private\\10281e17\\[FFFF4324]t_sqlbur_test3.db");
1.54 +_LIT(KTestFile4, "c:\\private\\10281e17\\[FFFF4324]t_sqlbur_test4.db");
1.55 +
1.56 +const TDriveNumber KTestDrive = EDriveC;
1.57 +
1.58 +const TUint KBufferSize = 2048; // used for reading backup files for validation
1.59 +
1.60 +static CActiveScheduler* TheScheduler = NULL;
1.61 +static CSqlSrvTestBurInterface* TheSqlSrvTestBurInterface = NULL;
1.62 +
1.63 +/////////////////////////////////////
1.64 +
1.65 +//Test db files
1.66 +_LIT(KTestDbFileName1,"C:[21212122]AADB2.db");
1.67 +_LIT(KTestDbFileName2,"C:[21212122]BBDB2.db");
1.68 +
1.69 +//Temp buffers for storing files content, to be compared with what is received after the restore operation. 10 files max.
1.70 +TInt TheFileCount = 0;
1.71 +const TInt KMaxDbFileSize = 10 * 1024;//The max test db file size - 10 Kb max.
1.72 +static TUint8 TheDbFileData[10][KMaxDbFileSize];//An array where the original db file content will be stored
1.73 +static TInt TheDbFileSizes[10];//An array where the real db file size will be stored
1.74 +static TUint8 TheBuf[KMaxDbFileSize];
1.75 +
1.76 +/////////////////////////////////////
1.77 +
1.78 +///////////////////////////////////////////////////////////////////////////////////////
1.79 +
1.80 +void DeleteBackupFiles()
1.81 + {
1.82 + TFileName fname;
1.83 +
1.84 + fname.Copy(KBackupFileTemplate);
1.85 + fname.Append((static_cast <TUid> (KClientUid)).Name());
1.86 + (void)TheSqlSrvTestBurInterface->Fs().Delete(fname);
1.87 +
1.88 + fname.Copy(KBackupFileTemplate);
1.89 + fname.Append((static_cast <TUid> (KZeroFileSizeUid)).Name());
1.90 + (void)TheSqlSrvTestBurInterface->Fs().Delete(fname);
1.91 +
1.92 + fname.Copy(KBackupFileTemplate);
1.93 + fname.Append((static_cast <TUid> (KTestClientUid1)).Name());
1.94 + (void)TheSqlSrvTestBurInterface->Fs().Delete(fname);
1.95 +
1.96 + fname.Copy(KBackupFileTemplate);
1.97 + fname.Append((static_cast <TUid> (KTestClientUid2)).Name());
1.98 + (void)TheSqlSrvTestBurInterface->Fs().Delete(fname);
1.99 +
1.100 + fname.Copy(KBackupFileTemplate);
1.101 + fname.Append((static_cast <TUid> (KTestClientUid3)).Name());
1.102 + (void)TheSqlSrvTestBurInterface->Fs().Delete(fname);
1.103 + }
1.104 +
1.105 +void TestEnvDestroy()
1.106 + {
1.107 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KBackupCopy);
1.108 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);
1.109 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1Bak);
1.110 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile3);
1.111 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile4);
1.112 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KZeroSizeFile);
1.113 +
1.114 + DeleteBackupFiles();
1.115 +
1.116 + delete TheSqlSrvTestBurInterface;
1.117 + TheSqlSrvTestBurInterface = NULL;
1.118 +
1.119 + delete TheScheduler;
1.120 + TheScheduler = NULL;
1.121 + }
1.122 +
1.123 +////////////////////////////
1.124 +// Test macros and functions
1.125 +////////////////////////////
1.126 +
1.127 +void Check(TInt aValue, TInt aLine)
1.128 + {
1.129 + if(!aValue)
1.130 + {
1.131 + TestEnvDestroy();
1.132 + TheTest(EFalse, aLine);
1.133 + }
1.134 + }
1.135 +
1.136 +void Check(TInt aValue, TInt aExpected, TInt aLine)
1.137 + {
1.138 + if(aValue != aExpected)
1.139 + {
1.140 + TestEnvDestroy();
1.141 + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
1.142 + TheTest(EFalse, aLine);
1.143 + }
1.144 + }
1.145 +#define TEST(arg) ::Check((arg), __LINE__)
1.146 +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
1.147 +
1.148 +///////////////////////////////////////////////////////////////////////////////////////
1.149 +
1.150 +static void DestroyFileList(RArray<HBufC*>& aFileList)
1.151 + {
1.152 + for(TInt i=0;i<aFileList.Count();++i)
1.153 + {
1.154 + delete aFileList[i];
1.155 + }
1.156 + aFileList.Close();
1.157 + }
1.158 +
1.159 +//CSqlSrvTestBurInterface - test implementation of the MSqlSrvBurInterface, implemented in the production code by the SQL server.
1.160 +CSqlSrvTestBurInterface *CSqlSrvTestBurInterface::New()
1.161 + {
1.162 + CSqlSrvTestBurInterface* self = new CSqlSrvTestBurInterface;
1.163 + TEST(self != NULL);
1.164 + self->Construct();
1.165 + return self;
1.166 + }
1.167 +
1.168 +CSqlSrvTestBurInterface::CSqlSrvTestBurInterface()
1.169 + {
1.170 + }
1.171 +
1.172 +void CSqlSrvTestBurInterface::Construct()
1.173 + {
1.174 + TInt err = iFs.Connect();
1.175 + TEST2(err, KErrNone);
1.176 + err = iFs.MkDir(KBackupDir);
1.177 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.178 + err = iFs.CreatePrivatePath(KTestDrive);
1.179 + TEST2(err, KErrNone);
1.180 + }
1.181 +
1.182 +CSqlSrvTestBurInterface::~CSqlSrvTestBurInterface()
1.183 + {
1.184 + iFs.Close();
1.185 + }
1.186 +
1.187 +//Called by the backup client ot get a list of database files to backup
1.188 +//The array is owned by the caller
1.189 +//The SQL server would have the job to get a list of databases owned by
1.190 +//the given SID and to determine whether the backup flag is set
1.191 +//All databases that satisfy this requirement will be added to the array.
1.192 +void CSqlSrvTestBurInterface::GetBackUpListL(TSecureId aUid, TDriveNumber aDrive, RArray<HBufC*>& aFileList)
1.193 + {
1.194 + if(aUid.iId == 0)
1.195 + {//Simulates that there are no databases for backup
1.196 + DestroyFileList(aFileList);
1.197 + return;
1.198 + }
1.199 +
1.200 + TDriveUnit driveUnit(aDrive);
1.201 + TDriveName driveName = driveUnit.Name();
1.202 + TFileName path;
1.203 + path.Copy(driveName);
1.204 + path.Append(KPrivateDir);
1.205 + //Include the aUid and the "*" mask
1.206 + TUidName uidName = (static_cast <TUid> (aUid)).Name();
1.207 + _LIT(KMatchAllDbFiles, "*");
1.208 + TBuf<KMaxUidName + sizeof(KMatchAllDbFiles)> fileNameMask(uidName);
1.209 + fileNameMask.Append(KMatchAllDbFiles);
1.210 + TParse parse;
1.211 + TInt err = parse.Set(path, &fileNameMask, NULL);
1.212 + User::LeaveIfError(err);
1.213 + //Do the search
1.214 + TPtrC fullPath(parse.FullName());
1.215 + CDir* fileNameCol = NULL;
1.216 + err = TheSqlSrvTestBurInterface->Fs().GetDir(fullPath, KEntryAttNormal, ESortNone, fileNameCol);
1.217 + if(err == KErrNotFound)
1.218 + {
1.219 + return;
1.220 + }
1.221 + User::LeaveIfError(err);
1.222 + CleanupStack::PushL(fileNameCol);
1.223 + TInt fileCount = fileNameCol->Count();
1.224 + err = aFileList.Reserve(fileCount);
1.225 + User::LeaveIfError(err);
1.226 + //Append the full database file paths to the file names list.
1.227 + for(TInt i=0;i<fileCount;++i)
1.228 + {
1.229 + const ::TEntry& entry = (*fileNameCol)[i];
1.230 + err = parse.Set(path, &entry.iName, NULL);
1.231 + User::LeaveIfError(err);
1.232 + TPtrC fname(parse.FullName());
1.233 + HBufC* fnameBuf = fname.AllocL();
1.234 + err = aFileList.Append(fnameBuf);
1.235 + User::LeaveIfError(err);
1.236 + }
1.237 + CleanupStack::PopAndDestroy(fileNameCol);
1.238 + }
1.239 +
1.240 +//Returns the file system resource handle to the caller.
1.241 +RFs& CSqlSrvTestBurInterface::Fs()
1.242 + {
1.243 + return iFs;
1.244 + }
1.245 +
1.246 +///////////////////////////////////////////////////////////////////////////////////////
1.247 +///////////////////////////////////////////////////////////////////////////////////////
1.248 +///////////////////////////////////////////////////////////////////////////////////////
1.249 +
1.250 +TBool FileExists(RFs& aFs, const TDesC& aFileName)
1.251 + {
1.252 + TEntry entry;
1.253 + return aFs.Entry(aFileName, entry) == KErrNone;
1.254 + }
1.255 +
1.256 +void TestEnvCreate()
1.257 + {
1.258 + TheScheduler = new CActiveScheduler;
1.259 + TEST(TheScheduler != NULL);
1.260 +
1.261 + CActiveScheduler::Install(TheScheduler);
1.262 +
1.263 + TheSqlSrvTestBurInterface = CSqlSrvTestBurInterface::New();
1.264 + TEST(TheSqlSrvTestBurInterface != NULL);
1.265 + }
1.266 +
1.267 +void PrepareSearchPath(TDriveNumber aDrive, TDes& aPath)
1.268 + {
1.269 + TDriveUnit driveUnit(aDrive);
1.270 + TDriveName driveName = driveUnit.Name();
1.271 + aPath.Copy(driveName);
1.272 + aPath.Append(KPrivateDir);
1.273 + }
1.274 +
1.275 +void PrepareSearchPattern(const TDesC& aPath, TSecureId aUid, TParse& aParse)
1.276 + {
1.277 + TUidName uidName = (static_cast <TUid> (aUid)).Name();
1.278 + _LIT(KMatchAllDbFiles, "*");
1.279 + TBuf<KMaxUidName + sizeof(KMatchAllDbFiles)> fileNameMask(uidName);
1.280 + fileNameMask.Append(KMatchAllDbFiles);
1.281 + TInt err = aParse.Set(aPath, &fileNameMask, NULL);
1.282 + TEST2(err, KErrNone);
1.283 + }
1.284 +
1.285 +//Reads the content of the db files and stores the content to a global memory buffer.
1.286 +//That buffer content will be used later for verification of the restore process.
1.287 +void StoreDbContentToBuf(RFs& aFs, TDriveNumber aDrive, TSecureId aUid)
1.288 + {
1.289 + TFileName path;
1.290 + PrepareSearchPath(aDrive, path);
1.291 + TParse parse;
1.292 + PrepareSearchPattern(path, aUid, parse);
1.293 +
1.294 + TheFileCount = -1;
1.295 + Mem::FillZ(TheDbFileData, sizeof(TheDbFileData));
1.296 + Mem::FillZ(TheDbFileSizes, sizeof(TheDbFileSizes));
1.297 +
1.298 + CDir* dir = NULL;
1.299 + TInt err = aFs.GetDir(parse.FullName(), KEntryAttNormal, ESortByName, dir);
1.300 + TEST2(err, KErrNone);
1.301 + TheFileCount = dir->Count();
1.302 + for(TInt i=0;i<TheFileCount;++i)
1.303 + {
1.304 + const ::TEntry& entry = (*dir)[i];
1.305 + err = parse.Set(path, &entry.iName, NULL);
1.306 + TEST2(err, KErrNone);
1.307 + TPtrC fname(parse.FullName());
1.308 +
1.309 + RFile dbFile;
1.310 + err = dbFile.Open(aFs, fname, EFileRead);
1.311 + TEST2(err, KErrNone);
1.312 +
1.313 + TInt fileSize = 0;
1.314 + err = dbFile.Size(fileSize);
1.315 + TEST2(err, KErrNone);
1.316 + TEST(fileSize > 0);
1.317 +
1.318 + TPtr8 bufptr(TheDbFileData[i], 0, KMaxDbFileSize);
1.319 + err = dbFile.Read(bufptr, fileSize);
1.320 + TEST2(err, KErrNone);
1.321 + TEST(fileSize == bufptr.Length());
1.322 +
1.323 + TheDbFileSizes[i] = fileSize;
1.324 +
1.325 + dbFile.Close();
1.326 + }
1.327 + delete dir;
1.328 + }
1.329 +
1.330 +//At the moment when this function is called, the db files content is already restored.
1.331 +//The function will open the restored db files and compare their content against the content
1.332 +//of the original db files (kept in a global memory buffer).
1.333 +void CompareDbContentWithBuf(RFs& aFs, TDriveNumber aDrive, TSecureId aUid)
1.334 + {
1.335 + TFileName path;
1.336 + PrepareSearchPath(aDrive, path);
1.337 + TParse parse;
1.338 + PrepareSearchPattern(path, aUid, parse);
1.339 +
1.340 + CDir* dir = NULL;
1.341 + TInt err = aFs.GetDir(parse.FullName(), KEntryAttNormal, ESortByName, dir);
1.342 + TEST2(err, KErrNone);
1.343 + TEST2(TheFileCount, dir->Count());
1.344 + for(TInt i=0;i<TheFileCount;++i)
1.345 + {
1.346 + TEST(TheDbFileSizes[i] > 0);
1.347 +
1.348 + const ::TEntry& entry = (*dir)[i];
1.349 + err = parse.Set(path, &entry.iName, NULL);
1.350 + TEST2(err, KErrNone);
1.351 + TPtrC fname(parse.FullName());
1.352 +
1.353 + RFile dbFile;
1.354 + TInt err = dbFile.Open(aFs, fname, EFileRead);
1.355 + TEST2(err, KErrNone);
1.356 +
1.357 + TInt fileSize = 0;
1.358 + err = dbFile.Size(fileSize);
1.359 + TEST2(err, KErrNone);
1.360 + TEST(fileSize > 0);
1.361 + TEST2(TheDbFileSizes[i], fileSize);
1.362 +
1.363 + TPtr8 bufptr(TheBuf, 0, KMaxDbFileSize);
1.364 + err = dbFile.Read(bufptr, fileSize);
1.365 + TEST2(err, KErrNone);
1.366 + TEST2(fileSize, bufptr.Length());
1.367 +
1.368 + err = Mem::Compare(TheBuf, fileSize, TheDbFileData[i], TheDbFileSizes[i]);
1.369 + TEST2(err, 0);
1.370 +
1.371 + dbFile.Close();
1.372 + }
1.373 + delete dir;
1.374 + }
1.375 +
1.376 +////////////////////////////////////////////////////////////////////////////////////////
1.377 +
1.378 +//The backup client will return a series of data chunks representing
1.379 +//one of more databases for the uid of the data owner.
1.380 +//This data is stored in a file on the C drive for the purposes of the test
1.381 +TInt TestBackupL(CSqlBurCallback &aBackupClient, RFs& aFs, TSecureId aUid, TDriveNumber aDrive, TInt aDataChunkSize = KBufferSize)
1.382 + {
1.383 + TFileName backupFileName;
1.384 + backupFileName.Copy(KBackupFileTemplate);
1.385 + backupFileName.Append((static_cast <TUid> (aUid)).Name());
1.386 +
1.387 + RFile file;
1.388 + CleanupClosePushL(file);
1.389 + TInt err = file.Replace(aFs, backupFileName, EFileWrite | EFileStream | EFileShareExclusive);
1.390 + User::LeaveIfError(err);
1.391 + aBackupClient.InitialiseGetProxyBackupDataL(aUid, aDrive);
1.392 +
1.393 + TBuf8<KBufferSize> buf;
1.394 + TPtr8 ptr((TUint8*)buf.Ptr(), aDataChunkSize);
1.395 + TBool finishedFlag = EFalse;
1.396 + TInt count = 0;
1.397 +
1.398 + do
1.399 + {
1.400 + aBackupClient.GetBackupDataSectionL(ptr, finishedFlag);
1.401 + count += ptr.Length();
1.402 + err = file.Write(ptr);
1.403 + User::LeaveIfError(err);
1.404 + ptr.SetLength(0);
1.405 + }
1.406 + while(!finishedFlag);
1.407 +
1.408 + CleanupStack::PopAndDestroy(&file);
1.409 +
1.410 + if(count == 0)
1.411 + {
1.412 + User::Leave(KErrEof);
1.413 + }
1.414 + if(!FileExists(aFs, backupFileName))
1.415 + {
1.416 + User::Leave(KErrNotFound);
1.417 + }
1.418 + TheTest.Printf(_L("Backup complete. %d bytes processed.\r\n"), count);
1.419 + return count;
1.420 + }
1.421 +
1.422 +//This sends the data in chunks form back to the BUR client
1.423 +//for nupacking and restoration of the original databases files
1.424 +TInt TestRestoreL(CSqlBurCallback &aRestoreClient, RFs& aFs, TSecureId aUid, TDriveNumber aDrive, TInt aDataChunkSize = KBufferSize)
1.425 + {
1.426 + TFileName backupFileName;
1.427 + backupFileName.Copy(KBackupFileTemplate);
1.428 + backupFileName.Append((static_cast <TUid> (aUid)).Name());
1.429 +
1.430 + RFile file;
1.431 + CleanupClosePushL(file);
1.432 + TInt err = file.Open(aFs, backupFileName, EFileRead | EFileShareExclusive);
1.433 + User::LeaveIfError(err);
1.434 + aRestoreClient.InitialiseRestoreProxyBaseDataL(aUid, aDrive);
1.435 +
1.436 + TBuf8<KBufferSize> buf;
1.437 + TPtr8 ptr((TUint8*)buf.Ptr(), aDataChunkSize);
1.438 + TBool finishedFlag = EFalse;
1.439 +
1.440 + TInt fileSize = 0;
1.441 + err = file.Size(fileSize);
1.442 + User::LeaveIfError(err);
1.443 + TInt count = fileSize;
1.444 +
1.445 + do
1.446 + {
1.447 + err = file.Read(ptr, aDataChunkSize);
1.448 + User::LeaveIfError(err);
1.449 + fileSize -= ptr.Length();
1.450 + finishedFlag = fileSize == 0;
1.451 + aRestoreClient.RestoreBaseDataSectionL(ptr, finishedFlag);
1.452 + ptr.SetLength(0);
1.453 + }
1.454 + while(fileSize > 0);
1.455 +
1.456 + CleanupStack::PopAndDestroy(&file);
1.457 +
1.458 + aRestoreClient.RestoreComplete(aDrive);
1.459 +
1.460 + if(!finishedFlag)
1.461 + {
1.462 + User::Leave(KErrEof);
1.463 + }
1.464 +
1.465 + TheTest.Printf(_L("Restore complete. %d bytes processed.\r\n"), count);
1.466 + return count;
1.467 + }
1.468 +
1.469 +//Verifies the integrity of the backup file.
1.470 +void TestArchiveIntegrityL(CSqlBurCallback &aBackupClient, RFs& aFs, TSecureId aUid)
1.471 + {
1.472 + RFile bkpFile;
1.473 + CleanupClosePushL(bkpFile);
1.474 +
1.475 + TFileName backupFileName;
1.476 + backupFileName.Copy(KBackupFileTemplate);
1.477 + backupFileName.Append((static_cast <TUid> (aUid)).Name());
1.478 +
1.479 + TInt err = bkpFile.Open(aFs, backupFileName, EFileRead | EFileShareExclusive);
1.480 + User::LeaveIfError(err);
1.481 +
1.482 + TBuf8<KBufferSize> buf;
1.483 + TPtr8 ptr((TUint8*)buf.Ptr(), buf.MaxLength());
1.484 +
1.485 + TInt bkpFileSize = 0;
1.486 + err = bkpFile.Size(bkpFileSize);
1.487 + User::LeaveIfError(err);
1.488 +
1.489 + while(bkpFileSize > 0)
1.490 + {
1.491 + // get the checksum
1.492 + err = bkpFile.Read(ptr, 16); // 8 UTF-16 characters
1.493 + User::LeaveIfError(err);
1.494 + if(ptr.Length() != 16)
1.495 + {
1.496 + User::Leave(KErrCorrupt);
1.497 + }
1.498 + TPtr ptr16((TUint16*) ptr.Ptr(), 8, 8);
1.499 + TLex lex(ptr16);
1.500 + TUint32 checksum;
1.501 + lex.SkipSpace();
1.502 + err = lex.Val(checksum, EHex);
1.503 + User::LeaveIfError(err);
1.504 + bkpFileSize -= 16;
1.505 +
1.506 + // get the old file size
1.507 + err = bkpFile.Read(ptr, 16); // 8 UTF-16 characters
1.508 + User::LeaveIfError(err);
1.509 + if(ptr.Length() != 16)
1.510 + {
1.511 + User::Leave(KErrCorrupt);
1.512 + }
1.513 + ptr16.Set((TUint16*) ptr.Ptr(), 8, 8);
1.514 + lex.Assign(ptr16);
1.515 + TUint32 oldFileSize;
1.516 + lex.SkipSpace();
1.517 + err = lex.Val(oldFileSize, EHex);
1.518 + User::LeaveIfError(err);
1.519 + bkpFileSize -= 16;
1.520 +
1.521 + // get the backup file header version
1.522 + err = bkpFile.Read(ptr, 8); // 4 UTF-16 characters
1.523 + User::LeaveIfError(err);
1.524 + ptr16.Set((TUint16*)ptr.Ptr(), 4, 4);
1.525 + lex.Assign(ptr16);
1.526 + TUint32 hdrVer;
1.527 + lex.SkipSpace();
1.528 + err = lex.Val(hdrVer, EHex);
1.529 + User::LeaveIfError(err);
1.530 + bkpFileSize -= 8;
1.531 +
1.532 + // get the file size
1.533 + err = bkpFile.Read(ptr, 32); // 16 UTF-16 characters
1.534 + User::LeaveIfError(err);
1.535 + if(ptr.Length() != 32)
1.536 + {
1.537 + User::Leave(KErrCorrupt);
1.538 + }
1.539 + ptr16.Set((TUint16*) ptr.Ptr(), 16, 16);
1.540 + lex.Assign(ptr16);
1.541 + TInt64 fileSize;
1.542 + lex.SkipSpace();
1.543 + err = lex.Val(fileSize, EHex);
1.544 + User::LeaveIfError(err);
1.545 + bkpFileSize -= 32;
1.546 +
1.547 + // get the filename size
1.548 + err = bkpFile.Read(ptr, 16); // 8 UTF-16 characters
1.549 + User::LeaveIfError(err);
1.550 + ptr16.Set((TUint16*)ptr.Ptr(), 8, 8);
1.551 + lex.Assign(ptr16);
1.552 + TUint32 fileNameSize;
1.553 + lex.SkipSpace();
1.554 + err = lex.Val(fileNameSize, EHex);
1.555 + User::LeaveIfError(err);
1.556 + bkpFileSize -= 16;
1.557 +
1.558 + // get the filename
1.559 + err = bkpFile.Read(ptr, fileNameSize * 2); // fileName UTF-16 characters
1.560 + User::LeaveIfError(err);
1.561 + if(ptr.Length() != (fileNameSize * 2))
1.562 + {
1.563 + User::Leave(KErrCorrupt);
1.564 + }
1.565 + ptr16.Set((TUint16*) ptr.Ptr(), fileNameSize, fileNameSize);
1.566 + lex.Assign(ptr16);
1.567 + TParse tp;
1.568 + tp.Set(ptr16, NULL, NULL);
1.569 + TPtrC dbFileName = tp.Name();
1.570 + bkpFileSize -= fileNameSize * 2;
1.571 +
1.572 + // open a local file - replaces any previous one
1.573 + RFile64 dbFile;
1.574 + CleanupClosePushL(dbFile);
1.575 + err = dbFile.Replace(aFs, dbFileName, EFileWrite | EFileShareExclusive);
1.576 + User::LeaveIfError(err);
1.577 +
1.578 + // copy all the data (file size bytes)
1.579 + TInt bytesLeftToRead = fileSize;
1.580 +
1.581 + while(bytesLeftToRead > 0)
1.582 + {
1.583 + TInt readSize = bytesLeftToRead > KBufferSize ? KBufferSize : bytesLeftToRead;
1.584 + err = bkpFile.Read(ptr, readSize);
1.585 + User::LeaveIfError(err);
1.586 + if(ptr.Length() != readSize)
1.587 + {
1.588 + User::Leave(KErrCorrupt);
1.589 + }
1.590 + bytesLeftToRead -= readSize;
1.591 + err = dbFile.Write(ptr, readSize);
1.592 + User::LeaveIfError(err);
1.593 + }
1.594 +
1.595 + bkpFileSize -= fileSize;
1.596 +
1.597 + // checksum the file
1.598 + TUint64 checkSum64 = 0;
1.599 + User::LeaveIfError(aBackupClient.CheckSum(dbFile, checkSum64));
1.600 + TUint32 checksum32 = checkSum64 & 0xFFFFFFFF;
1.601 +
1.602 + if(checksum != checksum32)
1.603 + {
1.604 + User::Leave(KErrCorrupt);
1.605 + }
1.606 +
1.607 + // all done with this file
1.608 + CleanupStack::PopAndDestroy(&dbFile);
1.609 + err = aFs.Delete(dbFileName);
1.610 + User::LeaveIfError(err);
1.611 + }
1.612 +
1.613 + CleanupStack::PopAndDestroy(&bkpFile);
1.614 + }
1.615 +
1.616 +/**
1.617 +@SYMTestCaseID SYSLIB-SQL-UT-4002
1.618 +@SYMTestCaseDesc Test for DEF113598 - "SQL, t_sqlbur unit test needs refactoring"
1.619 + The test backups 2 test db files, then verifies the backup file integrity,
1.620 + then restores the test db files content from the backup file.
1.621 + At the end, the test checks that the restored test db files content is the
1.622 + same as the content of the original test db file.
1.623 +@SYMTestPriority High
1.624 +@SYMTestActions Test for DEF113598 - "SQL, t_sqlbur unit test needs refactoring"
1.625 +@SYMTestExpectedResults Test must not fail
1.626 +@SYMDEF DEF113598
1.627 +*/
1.628 +void FunctionalTest()
1.629 + {
1.630 + CSqlBurCallback* backupClient = NULL;
1.631 + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.632 + TEST(backupClient != NULL);
1.633 +
1.634 + ////////////////////////////////////////
1.635 +
1.636 + //Virtual functions - with default implementation
1.637 +
1.638 + (void)backupClient->GetExpectedDataSize(KTestDrive);
1.639 +
1.640 + (void)backupClient->GetDataChecksum(KTestDrive);
1.641 +
1.642 + TBool finished = EFalse;
1.643 + TPtr8 ptr(0, 0, 0);
1.644 + TRAP(err, backupClient->GetSnapshotDataL(KTestDrive, ptr, finished));
1.645 + TEST2(err, KErrNotSupported);
1.646 +
1.647 + TRAP(err, backupClient->InitialiseGetBackupDataL(KTestDrive));
1.648 + TEST2(err, KErrNotSupported);
1.649 +
1.650 + TRAP(err, backupClient->InitialiseRestoreBaseDataL(KTestDrive));
1.651 + TEST2(err, KErrNotSupported);
1.652 +
1.653 + TRAP(err, backupClient->InitialiseRestoreIncrementDataL(KTestDrive));
1.654 + TEST2(err, KErrNotSupported);
1.655 +
1.656 + TPtrC8 ptr2(KNullDesC8);
1.657 + TRAP(err, backupClient->RestoreIncrementDataSectionL(ptr2, finished));
1.658 + TEST2(err, KErrNotSupported);
1.659 +
1.660 + TRAP(err, backupClient->AllSnapshotsSuppliedL());
1.661 + TEST2(err, KErrNone);
1.662 +
1.663 + TRAP(err, backupClient->ReceiveSnapshotDataL(KTestDrive, ptr2, finished));
1.664 + TEST2(err, KErrNotSupported);
1.665 +
1.666 + backupClient->TerminateMultiStageOperation();
1.667 +
1.668 + ////////////////////////////////////////
1.669 +
1.670 + TInt bytesStored = 0;
1.671 + TRAP(err, bytesStored = TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KClientUid, KTestDrive));
1.672 + TEST2(err, KErrNone);
1.673 +
1.674 + TheTest.Next(_L("Archive integrity test"));
1.675 +
1.676 + TRAP(err, TestArchiveIntegrityL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KClientUid));
1.677 + TEST2(err, KErrNone);
1.678 +
1.679 + delete backupClient;
1.680 +
1.681 + TheTest.Next(_L("Restore: functional test"));
1.682 +
1.683 + CSqlBurCallback* restoreClient = NULL;
1.684 + TRAP(err, restoreClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.685 + TEST(restoreClient != NULL);
1.686 +
1.687 + TInt bytesRestored = 0;
1.688 + TRAP(err, bytesRestored = TestRestoreL(*restoreClient, TheSqlSrvTestBurInterface->Fs(), KClientUid, KTestDrive));
1.689 + TEST2(err, KErrNone);
1.690 +
1.691 + TEST(bytesRestored == bytesStored);
1.692 +
1.693 + delete restoreClient;
1.694 +
1.695 + CompareDbContentWithBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid);
1.696 + }
1.697 +
1.698 +TInt DoBackupL(TDriveNumber aDrive, TSecureId aUid)
1.699 + {
1.700 + CSqlBurCallback* backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface);
1.701 + CleanupStack::PushL(backupClient);
1.702 + TInt bytesStored = TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), aUid, aDrive);
1.703 + CleanupStack::PopAndDestroy(backupClient);
1.704 + return bytesStored;
1.705 + }
1.706 +
1.707 +TInt DoRestoreL(TDriveNumber aDrive, TSecureId aUid)
1.708 + {
1.709 + CSqlBurCallback* restoreClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface);
1.710 + CleanupStack::PushL(restoreClient);
1.711 + TInt bytesRestored = TestRestoreL(*restoreClient, TheSqlSrvTestBurInterface->Fs(), aUid, aDrive);
1.712 + CleanupStack::PopAndDestroy(restoreClient);
1.713 + return bytesRestored;
1.714 + }
1.715 +
1.716 +/**
1.717 +@SYMTestCaseID SYSLIB-SQL-UT-4003
1.718 +@SYMTestCaseDesc Test for DEF113598 - "SQL, t_sqlbur unit test needs refactoring"
1.719 + Under simulated OOM condition, the test backups 2 test db files,
1.720 + then restores the test db files content from the backup file.
1.721 + At the end, the test checks that the restored test db files content is the
1.722 + same as the content of the original test db file.
1.723 +@SYMTestPriority High
1.724 +@SYMTestActions Test for DEF113598 - "SQL, t_sqlbur unit test needs refactoring"
1.725 +@SYMTestExpectedResults Test must not fail
1.726 +@SYMDEF DEF113598
1.727 +*/
1.728 +void OomTest()
1.729 + {
1.730 + ///////////////////////////////////////////////////////////////////////////////
1.731 + TInt err = KErrNoMemory;
1.732 + TInt bytesStored = 0;
1.733 + TInt count = 0;
1.734 +
1.735 + for(count=1;err==KErrNoMemory;++count)
1.736 + {
1.737 + TInt startProcessHandleCount;
1.738 + TInt startThreadHandleCount;
1.739 + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
1.740 +
1.741 + User::__DbgMarkStart(RHeap::EUser);
1.742 + User::__DbgSetAllocFail(RHeap::EUser,RHeap::EFailNext, count);
1.743 + TRAP(err, bytesStored = DoBackupL(KTestDrive, KClientUid));
1.744 + User::__DbgMarkEnd(RHeap::EUser, 0);
1.745 +
1.746 + TInt endProcessHandleCount;
1.747 + TInt endThreadHandleCount;
1.748 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.749 +
1.750 + TEST(startProcessHandleCount == endProcessHandleCount);
1.751 + TEST(startThreadHandleCount == endThreadHandleCount);
1.752 + }
1.753 + TEST2(err, KErrNone);
1.754 + TheTest.Printf(_L("OOM backup test succeeded at heap failure rate of %d\r\n"), count);
1.755 +
1.756 + ///////////////////////////////////////////////////////////////////////////////
1.757 + TheTest.Next(_L("Restore: OOM test"));
1.758 + err = KErrNoMemory;
1.759 + TInt bytesRestored = 0;
1.760 +
1.761 + for(count=1;err==KErrNoMemory;++count)
1.762 + {
1.763 + TInt startProcessHandleCount;
1.764 + TInt startThreadHandleCount;
1.765 + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
1.766 +
1.767 + User::__DbgMarkStart(RHeap::EUser);
1.768 + User::__DbgSetAllocFail(RHeap::EUser,RHeap::EFailNext, count);
1.769 + TRAP(err, bytesRestored = DoRestoreL(KTestDrive, KClientUid));
1.770 + User::__DbgMarkEnd(RHeap::EUser, 0);
1.771 +
1.772 + TInt endProcessHandleCount;
1.773 + TInt endThreadHandleCount;
1.774 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.775 +
1.776 + TEST(startProcessHandleCount == endProcessHandleCount);
1.777 + TEST(startThreadHandleCount == endThreadHandleCount);
1.778 + }
1.779 + TEST2(err, KErrNone);
1.780 + User::__DbgSetAllocFail(RHeap::EUser, RAllocator::ENone, 0);
1.781 + TheTest.Printf(_L("OOM restore test succeeded at heap failure rate of %d\r\n"), count);
1.782 +
1.783 + TEST2(bytesStored, bytesRestored);
1.784 +
1.785 + CompareDbContentWithBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid);
1.786 + }
1.787 +
1.788 +/**
1.789 +@SYMTestCaseID PDS-SQL-UT-4143
1.790 +@SYMTestCaseDesc SQL Backup&Restore - data chunk size test.
1.791 + The test uses an integer array of 10 elements with randomly generated data chunk sizes.
1.792 + Then the test runs 10 backup iterations using each time different data chunk size.
1.793 + After each backup iteration the test performs a restore operation and checks that the
1.794 + data has been backup&restored without errors.
1.795 +@SYMTestActions SQL Backup&Restore - data chunk size test.
1.796 +@SYMTestExpectedResults Test must not fail
1.797 +@SYMTestPriority Medium
1.798 +@SYMREQ REQ12104
1.799 +*/
1.800 +void FunctionalTest2()
1.801 + {
1.802 + TTime now;
1.803 + now.UniversalTime();
1.804 + TInt64 seed = now.Int64();
1.805 +
1.806 + const TInt KArraySize = 10;
1.807 + TInt dataChunks[10] = {2, 6, 0, 0, 0, 0, 0, 0, 0, 0};
1.808 + const TInt KMaxDataChunkSize = 50;
1.809 +
1.810 + for(TInt i=2;i<KArraySize;)
1.811 + {
1.812 + TInt dataChunkSize = Math::Rand(seed) % KMaxDataChunkSize;
1.813 + if((dataChunkSize % 2) == 0 && dataChunkSize != 0) //The code works only with data chunks with even sizes!!!
1.814 + {
1.815 + dataChunks[i++] = dataChunkSize;
1.816 + }
1.817 + }
1.818 +
1.819 + for(TInt i=0;i<KArraySize;++i)
1.820 + {
1.821 + TheTest.Printf(_L(" === Iteration %d, chunk size %d\r\n"), i + 1, dataChunks[i]);
1.822 + CSqlBurCallback* backupClient = NULL;
1.823 + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.824 + TEST(backupClient != NULL);
1.825 +
1.826 + TInt bytesStored = 0;
1.827 + TRAP(err, bytesStored = TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KClientUid, KTestDrive, dataChunks[i]));
1.828 + TEST2(err, KErrNone);
1.829 +
1.830 + TRAP(err, TestArchiveIntegrityL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KClientUid));
1.831 + TEST2(err, KErrNone);
1.832 +
1.833 + delete backupClient;
1.834 +
1.835 + CSqlBurCallback* restoreClient = NULL;
1.836 + TRAP(err, restoreClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.837 + TEST(restoreClient != NULL);
1.838 +
1.839 + TInt bytesRestored = 0;
1.840 + TRAP(err, bytesRestored = TestRestoreL(*restoreClient, TheSqlSrvTestBurInterface->Fs(), KClientUid, KTestDrive, dataChunks[i]));
1.841 + TEST2(err, KErrNone);
1.842 +
1.843 + TEST(bytesRestored == bytesStored);
1.844 +
1.845 + delete restoreClient;
1.846 +
1.847 + CompareDbContentWithBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid);
1.848 + }
1.849 + }
1.850 +
1.851 +/**
1.852 +@SYMTestCaseID PDS-SQL-UT-4144
1.853 +@SYMTestCaseDesc SQL Backup&Restore - legacy backup file format header test.
1.854 + The 64-bit file system related changes made in the SQL server required some
1.855 + changes to be made in the format of the backup file header.
1.856 + The test checks that a backup file created with the previous format of the file header
1.857 + can be restored without errors by the updated Backup&Restore implementation.
1.858 +@SYMTestActions SQL Backup&Restore - legacy backup file format header test.
1.859 +@SYMTestExpectedResults Test must not fail
1.860 +@SYMTestPriority Medium
1.861 +@SYMREQ REQ12104
1.862 +*/
1.863 +void LegacyFileFormatTest()
1.864 + {
1.865 + //KBackupFile2 is a database backup file with header version 0.
1.866 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KBackupFile2);
1.867 + TInt rc = BaflUtils::CopyFile(TheSqlSrvTestBurInterface->Fs(), KBackupFile2Z, KBackupFile2);
1.868 + TEST2(rc, KErrNone);
1.869 + (void)TheSqlSrvTestBurInterface->Fs().SetAtt(KBackupFile2, 0, KEntryAttReadOnly);
1.870 +
1.871 + //Restore the databases from KBackupFile2.
1.872 + CSqlBurCallback* restoreClient = NULL;
1.873 + TRAP(rc, restoreClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.874 + TEST(restoreClient != NULL);
1.875 +
1.876 + RFile file;
1.877 + rc = file.Open(TheSqlSrvTestBurInterface->Fs(), KBackupFile2, EFileRead | EFileShareExclusive);
1.878 + TEST2(rc, KErrNone);
1.879 +
1.880 + TRAP(rc, restoreClient->InitialiseRestoreProxyBaseDataL(KClientUid, KTestDrive));
1.881 + TEST2(rc, KErrNone);
1.882 +
1.883 + TBuf8<KBufferSize> buf;
1.884 + TPtr8 ptr((TUint8*)buf.Ptr(), buf.MaxSize());
1.885 + TBool finishedFlag = EFalse;
1.886 +
1.887 + TInt fileSize = 0;
1.888 + rc = file.Size(fileSize);
1.889 + TEST2(rc, KErrNone);
1.890 +
1.891 + do
1.892 + {
1.893 + rc = file.Read(ptr);
1.894 + TEST2(rc, KErrNone);
1.895 + fileSize -= ptr.Size();
1.896 + finishedFlag = fileSize == 0;
1.897 + TRAP(rc, restoreClient->RestoreBaseDataSectionL(ptr, finishedFlag));
1.898 + ptr.SetLength(0);
1.899 + }
1.900 + while(fileSize > 0);
1.901 +
1.902 + file.Close();
1.903 +
1.904 + restoreClient->RestoreComplete(KTestDrive);
1.905 +
1.906 + TEST(finishedFlag);
1.907 +
1.908 + delete restoreClient;
1.909 +
1.910 + //At this point we have two restored databases: KTestDbFileName1 and KTestDbFileName2.
1.911 + //The content of the restored file cannot be compared directly, because t_sqlattach uses the same test databases
1.912 + //and modifies them. The original database content was stored without executing t_sqlattach.
1.913 + //Hence a simple test is made: open the restored database, check if the database content can be accessed.
1.914 +
1.915 + RSqlDatabase db;
1.916 + rc = db.Open(KTestDbFileName1);
1.917 + TEST2(rc, KErrNone);
1.918 + //The database contains this table: "TABLE C(A1 INTEGER, B2 BLOB)".
1.919 + rc = db.Exec(_L("INSERT INTO C VALUES(100, 200)"));
1.920 + TEST2(rc, 1);
1.921 + RSqlStatement stmt;
1.922 + rc = stmt.Prepare(db, _L("SELECT * FROM C"));
1.923 + TEST2(rc, KErrNone);
1.924 + while((rc = stmt.Next()) == KSqlAtRow)
1.925 + {
1.926 + }
1.927 + stmt.Close();
1.928 + TEST2(rc, KSqlAtEnd);
1.929 + db.Close();
1.930 +
1.931 + rc = db.Open(KTestDbFileName2);
1.932 + TEST2(rc, KErrNone);
1.933 + //The database contains this table: "TABLE A1(F1 INTEGER , F2 INTEGER, B1 BLOB)"
1.934 + rc = db.Exec(_L("INSERT INTO A1 VALUES(100, 200, NULL)"));
1.935 + TEST2(rc, 1);
1.936 + rc = stmt.Prepare(db, _L("SELECT * FROM A1"));
1.937 + TEST2(rc, KErrNone);
1.938 + while((rc = stmt.Next()) == KSqlAtRow)
1.939 + {
1.940 + }
1.941 + stmt.Close();
1.942 + TEST2(rc, KSqlAtEnd);
1.943 + db.Close();
1.944 +
1.945 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KBackupFile2);
1.946 + }
1.947 +
1.948 +/**
1.949 +@SYMTestCaseID PDS-SQL-UT-4192
1.950 +@SYMTestCaseDesc SQL Backup&Restore - empty backup file list test.
1.951 + The test checks what will happen if the list with the files for backup is empty.
1.952 + The GetBackupDataSectionL() should immediatelly set the flag parameter to true and do nothing.
1.953 +@SYMTestActions SQL Backup&Restore - empty backup file list test.
1.954 +@SYMTestExpectedResults Test must not fail
1.955 +@SYMTestPriority High
1.956 +@SYMDEF DEF145198
1.957 +*/
1.958 +void EmptyBackupFileListTest()
1.959 + {
1.960 + CSqlBurCallback* backupClient = NULL;
1.961 + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.962 + TEST(backupClient != NULL);
1.963 +
1.964 + TRAP(err, backupClient->InitialiseGetProxyBackupDataL(KNullUid, KTestDrive));
1.965 + TEST2(err, KErrNone);
1.966 +
1.967 + TBuf8<100> buf;
1.968 + TPtr8 ptr((TUint8*)buf.Ptr(), 0, buf.MaxLength());
1.969 + TBool finishedFlag = EFalse;
1.970 + TRAP(err, backupClient->GetBackupDataSectionL(ptr, finishedFlag));
1.971 + delete backupClient;
1.972 + TEST2(err, KErrNone);
1.973 + TEST(finishedFlag);
1.974 + TEST2(buf.Length(), 0);
1.975 + }
1.976 +
1.977 +
1.978 +/**
1.979 +@SYMTestCaseID PDS-SQL-UT-4193
1.980 +@SYMTestCaseDesc SQL Backup&Restore - file I/O error simulation test.
1.981 + The test executes a backup, followed by a restore operation
1.982 + in a file I/O error simulation loop.
1.983 +@SYMTestActions SQL Backup&Restore - file I/O error simulation test.
1.984 +@SYMTestExpectedResults Test must not fail
1.985 +@SYMTestPriority High
1.986 +@SYMDEF DEF145198
1.987 +*/
1.988 +void BackupRestoreFileIoErrTest()
1.989 + {
1.990 + //Make sure that the database content, just before the backup, will be copied to the test biffers.
1.991 + //The buffers will be used during the restore testing for verification of the database content.
1.992 + StoreDbContentToBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid);
1.993 +
1.994 + for(TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)
1.995 + {
1.996 + TheTest.Printf(_L("===Backup&Restore, simulated file system error=%d\r\n"), fsError);
1.997 +
1.998 + TInt err = KErrGeneral;
1.999 + TInt bytesStored = -1;
1.1000 + TInt it_cnt1 = 0;
1.1001 + for(;err<KErrNone;++it_cnt1)
1.1002 + {
1.1003 + __UHEAP_MARK;
1.1004 + (void)TheSqlSrvTestBurInterface->Fs().SetErrorCondition(fsError, it_cnt1);
1.1005 + TRAP(err, bytesStored = DoBackupL(KTestDrive, KClientUid));
1.1006 + (void)TheSqlSrvTestBurInterface->Fs().SetErrorCondition(KErrNone);
1.1007 + __UHEAP_MARKEND;
1.1008 + }
1.1009 + TEST2(err, KErrNone);
1.1010 +
1.1011 + err = KErrGeneral;
1.1012 + TInt bytesRestored = -1;
1.1013 + TInt it_cnt2 = 0;
1.1014 + for(;err<KErrNone;++it_cnt2)
1.1015 + {
1.1016 + __UHEAP_MARK;
1.1017 + (void)TheSqlSrvTestBurInterface->Fs().SetErrorCondition(fsError, it_cnt2);
1.1018 + TRAP(err, bytesRestored = DoRestoreL(KTestDrive, KClientUid));
1.1019 + (void)TheSqlSrvTestBurInterface->Fs().SetErrorCondition(KErrNone);
1.1020 + __UHEAP_MARKEND;
1.1021 + }
1.1022 + TEST2(err, KErrNone);
1.1023 +
1.1024 + TEST2(bytesStored, bytesRestored);
1.1025 + CompareDbContentWithBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid);
1.1026 +
1.1027 + 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);
1.1028 + }
1.1029 + }
1.1030 +
1.1031 +/**
1.1032 +@SYMTestCaseID PDS-SQL-UT-4225
1.1033 +@SYMTestCaseDesc SQL Backup - zero size file backup.
1.1034 + The test executes a backup on a file with zero size.
1.1035 +@SYMTestActions SQL Backup - zero size file backup.
1.1036 +@SYMTestExpectedResults Test must not fail
1.1037 +@SYMTestPriority High
1.1038 +*/
1.1039 +void BackupZeroSizeFileTest()
1.1040 + {
1.1041 + CSqlBurCallback* backupClient = NULL;
1.1042 + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.1043 + TEST2(err, KErrNone);
1.1044 + TEST(backupClient != NULL);
1.1045 + //
1.1046 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KZeroSizeFile);
1.1047 + RFile file;
1.1048 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KZeroSizeFile, EFileRead | EFileWrite);
1.1049 + TEST2(err, KErrNone);
1.1050 + file.Close();
1.1051 + //
1.1052 + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KZeroFileSizeUid, KTestDrive));
1.1053 + TEST2(err, KErrNone);
1.1054 + //Write something to the file
1.1055 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KZeroSizeFile, EFileRead | EFileWrite);
1.1056 + TEST2(err, KErrNone);
1.1057 + _LIT8(KData, "123456787989");
1.1058 + err = file.Write(KData);
1.1059 + TEST2(err, KErrNone);
1.1060 + err = file.Flush();
1.1061 + TEST2(err, KErrNone);
1.1062 + file.Close();
1.1063 + //Do the restore. After the restore the file size should be 0.
1.1064 + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KZeroFileSizeUid, KTestDrive));
1.1065 + TEST2(err, KErrNone);
1.1066 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KZeroSizeFile, EFileRead | EFileWrite);
1.1067 + TEST2(err, KErrNone);
1.1068 + TInt size;
1.1069 + err = file.Size(size);
1.1070 + TEST2(err, KErrNone);
1.1071 + file.Close();
1.1072 + TEST2(size, 0);
1.1073 + //Write something to the file
1.1074 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KZeroSizeFile, EFileRead | EFileWrite);
1.1075 + TEST2(err, KErrNone);
1.1076 + err = file.Write(KData);
1.1077 + TEST2(err, KErrNone);
1.1078 + err = file.Flush();
1.1079 + TEST2(err, KErrNone);
1.1080 + file.Close();
1.1081 + //Call RestoreBaseDataSectionL() with 0 data in the input buffer and finished flag: false.
1.1082 + TRAP(err, backupClient->InitialiseRestoreProxyBaseDataL(KZeroFileSizeUid, KTestDrive));
1.1083 + TEST2(err, KErrNone);
1.1084 + TPtrC8 zeroBuf;
1.1085 + TRAP(err, backupClient->RestoreBaseDataSectionL(zeroBuf, EFalse));
1.1086 + TEST2(err, KErrNone);
1.1087 + //No restore in this case,
1.1088 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KZeroSizeFile, EFileRead | EFileWrite);
1.1089 + TEST2(err, KErrNone);
1.1090 + err = file.Size(size);
1.1091 + TEST2(err, KErrNone);
1.1092 + file.Close();
1.1093 + TEST(size > 0);
1.1094 + //Call RestoreBaseDataSectionL() with 0 data in the input buffer and finished flag: true.
1.1095 + TRAP(err, backupClient->InitialiseRestoreProxyBaseDataL(KZeroFileSizeUid, KTestDrive));
1.1096 + TEST2(err, KErrNone);
1.1097 + TRAP(err, backupClient->RestoreBaseDataSectionL(zeroBuf, ETrue));
1.1098 + TEST2(err, KErrNone);
1.1099 + //No restore in this case,
1.1100 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KZeroSizeFile, EFileRead | EFileWrite);
1.1101 + TEST2(err, KErrNone);
1.1102 + err = file.Size(size);
1.1103 + TEST2(err, KErrNone);
1.1104 + file.Close();
1.1105 + TEST(size > 0);
1.1106 + //
1.1107 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KZeroSizeFile);
1.1108 + delete backupClient;
1.1109 + }
1.1110 +
1.1111 +/**
1.1112 +@SYMTestCaseID PDS-SQL-UT-4226
1.1113 +@SYMTestCaseDesc SQL Restore - corrupted archive 1.
1.1114 + The test does a backup of a file with a non-zero size.
1.1115 + The the test modifies the archive, simulating a corruption.
1.1116 + The the test performs a restore from the archive. The corruption
1.1117 + should be detected and reported by SQL B&R code.
1.1118 +@SYMTestActions SQL Restore - corrupted archive 1.
1.1119 +@SYMTestExpectedResults Test must not fail
1.1120 +@SYMTestPriority High
1.1121 +*/
1.1122 +void CorruptedArchiveTest1()
1.1123 + {
1.1124 + CSqlBurCallback* backupClient = NULL;
1.1125 + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.1126 + TEST2(err, KErrNone);
1.1127 + TEST(backupClient != NULL);
1.1128 + //Create the test file that will be sent for backup
1.1129 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);
1.1130 + RFile file;
1.1131 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite);
1.1132 + TEST2(err, KErrNone);
1.1133 + _LIT8(KData1, "123456787989");
1.1134 + err = file.Write(KData1);
1.1135 + TEST2(err, KErrNone);
1.1136 + err = file.Flush();
1.1137 + TEST2(err, KErrNone);
1.1138 + file.Close();
1.1139 + //Backup the file
1.1140 + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive));
1.1141 + TEST2(err, KErrNone);
1.1142 + //Modify the file, which was sent for backup
1.1143 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite);
1.1144 + TEST2(err, KErrNone);
1.1145 + _LIT8(KData2, "ABCDEFGH");
1.1146 + err = file.Write(KData2);
1.1147 + TEST2(err, KErrNone);
1.1148 + err = file.SetSize(KData2().Length());
1.1149 + TEST2(err, KErrNone);
1.1150 + err = file.Flush();
1.1151 + TEST2(err, KErrNone);
1.1152 + file.Close();
1.1153 + //Corrupt the archive
1.1154 + TFileName backupFileName;
1.1155 + backupFileName.Copy(KBackupFileTemplate);
1.1156 + backupFileName.Append((static_cast <TUid> (KTestClientUid1)).Name());
1.1157 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), backupFileName, EFileRead | EFileWrite);
1.1158 + TEST2(err, KErrNone);
1.1159 + TInt pos = -3;
1.1160 + err = file.Seek(ESeekEnd, pos);
1.1161 + TEST2(err, KErrNone);
1.1162 + _LIT8(KData3, "ERR");
1.1163 + err = file.Write(KData3);
1.1164 + TEST2(err, KErrNone);
1.1165 + err = file.Flush();
1.1166 + TEST2(err, KErrNone);
1.1167 + file.Close();
1.1168 + //Try to restore the archive
1.1169 + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive));
1.1170 + TEST2(err, KErrCorrupt);
1.1171 + //Check that the file really has not been restored
1.1172 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite);
1.1173 + TEST2(err, KErrNone);
1.1174 + TBuf8<50> data;
1.1175 + err = file.Read(data);
1.1176 + TEST2(err, KErrNone);
1.1177 + file.Close();
1.1178 + TEST(data == KData2);
1.1179 + //
1.1180 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);
1.1181 + delete backupClient;
1.1182 + }
1.1183 +
1.1184 +/**
1.1185 +@SYMTestCaseID PDS-SQL-UT-4227
1.1186 +@SYMTestCaseDesc SQL Restore - corrupted archive 2.
1.1187 + The test does a backup of a file with a non-zero size.
1.1188 + Then the test modifies the archive, byte after byte each step,
1.1189 + simulating a corruption.
1.1190 + The the test performs a restore from the archive. The corruption
1.1191 + should be detected and reported by SQL B&R code.
1.1192 +@SYMTestActions SQL Restore - corrupted archive 2.
1.1193 +@SYMTestExpectedResults Test must not fail
1.1194 +@SYMTestPriority High
1.1195 +*/
1.1196 +void CorruptedArchiveTest2()
1.1197 + {
1.1198 + CSqlBurCallback* backupClient = NULL;
1.1199 + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.1200 + TEST2(err, KErrNone);
1.1201 + TEST(backupClient != NULL);
1.1202 + //Create the test file that will be sent for backup
1.1203 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);
1.1204 + RFile file;
1.1205 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite);
1.1206 + TEST2(err, KErrNone);
1.1207 + _LIT8(KData1, "123456787989");
1.1208 + err = file.Write(KData1);
1.1209 + TEST2(err, KErrNone);
1.1210 + err = file.Flush();
1.1211 + TEST2(err, KErrNone);
1.1212 + file.Close();
1.1213 + //Backup the file
1.1214 + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive));
1.1215 + TEST2(err, KErrNone);
1.1216 + //Modify the file, which was sent for backup
1.1217 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite);
1.1218 + TEST2(err, KErrNone);
1.1219 + _LIT8(KData2, "ABCDEFGH");
1.1220 + err = file.Write(KData2);
1.1221 + TEST2(err, KErrNone);
1.1222 + err = file.SetSize(KData2().Length());
1.1223 + TEST2(err, KErrNone);
1.1224 + err = file.Flush();
1.1225 + TEST2(err, KErrNone);
1.1226 + file.Close();
1.1227 + //Make a copy of the modified file
1.1228 + CFileMan* fm = NULL;
1.1229 + TRAP(err, fm = CFileMan::NewL(TheSqlSrvTestBurInterface->Fs()));
1.1230 + TEST2(err, KErrNone);
1.1231 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1Bak);
1.1232 + err = fm->Copy(KTestFile1, KTestFile1Bak);
1.1233 + TEST2(err, KErrNone);
1.1234 + //Get the archive size
1.1235 + TFileName backupFileName;
1.1236 + backupFileName.Copy(KBackupFileTemplate);
1.1237 + backupFileName.Append((static_cast <TUid> (KTestClientUid1)).Name());
1.1238 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), backupFileName, EFileRead | EFileWrite);
1.1239 + TEST2(err, KErrNone);
1.1240 + TInt size = 0;
1.1241 + err = file.Size(size);
1.1242 + TEST2(err, KErrNone);
1.1243 + file.Close();
1.1244 + //Save a copy of the archive
1.1245 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KBackupCopy);
1.1246 + err = fm->Copy(backupFileName, KBackupCopy);
1.1247 + TEST2(err, KErrNone);
1.1248 + //On each iteration step: corrupt the archive and try to do a restore from it.
1.1249 + for(TInt i=0;i<size;++i)
1.1250 + {
1.1251 + //Change 1 byte in the archive
1.1252 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), backupFileName, EFileRead | EFileWrite);
1.1253 + TEST2(err, KErrNone);
1.1254 + TInt pos = i;
1.1255 + err = file.Seek(ESeekStart, pos);
1.1256 + TEST2(err, KErrNone);
1.1257 + TBuf8<1> byte;
1.1258 + err = file.Read(byte);
1.1259 + TEST2(err, KErrNone);
1.1260 + ++byte[0];
1.1261 + err = file.Seek(ESeekStart, pos);
1.1262 + TEST2(err, KErrNone);
1.1263 + err = file.Write(byte);
1.1264 + TEST2(err, KErrNone);
1.1265 + if(i == (size - 1) && (size & 0x01) == 0)
1.1266 + {//Make the file size an odd number, just to test....
1.1267 + err = file.Write(byte);
1.1268 + TEST2(err, KErrNone);
1.1269 + }
1.1270 + err = file.Flush();
1.1271 + TEST2(err, KErrNone);
1.1272 + file.Close();
1.1273 + //Restore
1.1274 + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive));
1.1275 + TheTest.Printf(_L("Iteration %d, err=%d\r\n"), i, err);
1.1276 + if(err == KErrNone)
1.1277 + {
1.1278 + //Delete the restored file. The reason that the restore didn't fail is because only the file data is
1.1279 + //protected with checksum. The restore file header - not. The restore completed, the data was restored
1.1280 + //to a file with different name. Or even to a file with the same name. Delete created file(s).
1.1281 + (void)fm->Delete(KTestDeleteMask1);
1.1282 + (void)fm->Delete(KTestDeleteMask2);
1.1283 + }
1.1284 + else
1.1285 + {
1.1286 + //The restore completed with an error. The file content is preserved.
1.1287 + //Check that the file content is the same.
1.1288 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite);
1.1289 + TEST2(err, KErrNone);
1.1290 + TBuf8<50> data;
1.1291 + err = file.Read(data);
1.1292 + TEST2(err, KErrNone);
1.1293 + file.Close();
1.1294 + TEST(data == KData2);
1.1295 + }
1.1296 + //Restore the file from the backup copy
1.1297 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);
1.1298 + err = fm->Copy(KTestFile1Bak, KTestFile1);
1.1299 + TEST2(err, KErrNone);
1.1300 + //Restore the archive from the good copy.
1.1301 + (void)TheSqlSrvTestBurInterface->Fs().Delete(backupFileName);
1.1302 + err = fm->Copy(KBackupCopy, backupFileName);
1.1303 + TEST2(err, KErrNone);
1.1304 + }
1.1305 + //
1.1306 + delete fm;
1.1307 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);
1.1308 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1Bak);
1.1309 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KBackupCopy);
1.1310 + delete backupClient;
1.1311 + }
1.1312 +
1.1313 +/**
1.1314 +@SYMTestCaseID PDS-SQL-UT-4228
1.1315 +@SYMTestCaseDesc SQL Backup&Restore on a drive different than KTestDrive (C: by default).
1.1316 + The test creates one database on KTestDrive and another database
1.1317 + with the same name on a drive different than KTestDrive.
1.1318 + Then the test backups the "not KTestDrive" drive and restores
1.1319 + the data after that. The test verifies that the backup&restore
1.1320 + really impacts only the other drive, not KTestDrive.
1.1321 +@SYMTestActions SQL Backup&Restore on a drive different than KTestDrive (C: by default).
1.1322 +@SYMTestExpectedResults Test must not fail
1.1323 +@SYMTestPriority High
1.1324 +*/
1.1325 +void DbDriveTest()
1.1326 + {
1.1327 + CSqlBurCallback* backupClient = NULL;
1.1328 + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.1329 + TEST2(err, KErrNone);
1.1330 + TEST(backupClient != NULL);
1.1331 + //
1.1332 + TDriveUnit driveUnitDefault(KTestDrive);
1.1333 + TDriveName driveNameDefault = driveUnitDefault.Name();
1.1334 + //Find a r/w drive, different than KTestDrive
1.1335 + TInt drive = EDriveA;
1.1336 + for(;drive<=EDriveZ;++drive)
1.1337 + {
1.1338 + if(drive == KTestDrive)
1.1339 + {
1.1340 + continue;
1.1341 + }
1.1342 + TDriveInfo driveInfo;
1.1343 + err = TheSqlSrvTestBurInterface->Fs().Drive(driveInfo, drive);
1.1344 + if(err != KErrNone)
1.1345 + {
1.1346 + continue;
1.1347 + }
1.1348 + if(driveInfo.iDriveAtt & KDriveAttRom)
1.1349 + {
1.1350 + continue;
1.1351 + }
1.1352 + //
1.1353 + TDriveUnit driveUnit(drive);
1.1354 + TDriveName driveName = driveUnit.Name();
1.1355 + //
1.1356 + TVolumeInfo vinfo;
1.1357 + err = TheSqlSrvTestBurInterface->Fs().Volume(vinfo, drive);
1.1358 + if(err != KErrNone)
1.1359 + {
1.1360 + TheTest.Printf(_L("Drive %S, RFs::Volume() err=%d\r\n"), &driveName, err);
1.1361 + continue;
1.1362 + }
1.1363 + //R/W drive found.
1.1364 + TheTest.Printf(_L("Test drive: %S\r\n"), &driveName);
1.1365 + TParse parse;
1.1366 + err = parse.Set(KTestFile2, &driveName, 0);
1.1367 + TEST2(err, KErrNone);
1.1368 + //Create the test file that will be sent for backup
1.1369 + TPtrC fname1(parse.FullName());
1.1370 + TheTest.Printf(_L("Test file 1: %S\r\n"), &fname1);
1.1371 + err = TheSqlSrvTestBurInterface->Fs().MkDirAll(parse.FullName());
1.1372 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.1373 + (void)TheSqlSrvTestBurInterface->Fs().Delete(parse.FullName());
1.1374 + RFile file;
1.1375 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), parse.FullName(), EFileRead | EFileWrite);
1.1376 + TEST2(err, KErrNone);
1.1377 + _LIT8(KData1, "123456787989");
1.1378 + err = file.Write(KData1);
1.1379 + TEST2(err, KErrNone);
1.1380 + err = file.Flush();
1.1381 + TEST2(err, KErrNone);
1.1382 + file.Close();
1.1383 + //Create a test file with the same name on drive KTestDrive
1.1384 + err = parse.Set(KTestFile2, &driveNameDefault, 0);
1.1385 + TEST2(err, KErrNone);
1.1386 + TPtrC fname2(parse.FullName());
1.1387 + TheTest.Printf(_L("Test file 2: %S\r\n"), &fname2);
1.1388 + (void)TheSqlSrvTestBurInterface->Fs().Delete(parse.FullName());
1.1389 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), parse.FullName(), EFileRead | EFileWrite);
1.1390 + TEST2(err, KErrNone);
1.1391 + _LIT8(KData2, "ABCDEFG");
1.1392 + err = file.Write(KData2);
1.1393 + TEST2(err, KErrNone);
1.1394 + err = file.Flush();
1.1395 + TEST2(err, KErrNone);
1.1396 + file.Close();
1.1397 + //Do the backup on "drive"
1.1398 + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid2, (TDriveNumber)drive));
1.1399 + TEST2(err, KErrNone);
1.1400 + //Modify the file that was sent for backup
1.1401 + err = parse.Set(KTestFile2, &driveName, 0);
1.1402 + TEST2(err, KErrNone);
1.1403 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), parse.FullName(), EFileRead | EFileWrite);
1.1404 + TEST2(err, KErrNone);
1.1405 + _LIT8(KData3, "ABCDEFGHYYYYYY");
1.1406 + err = file.Write(KData3);
1.1407 + TEST2(err, KErrNone);
1.1408 + err = file.Flush();
1.1409 + TEST2(err, KErrNone);
1.1410 + file.Close();
1.1411 + //Do the restore on "drive"
1.1412 + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid2, (TDriveNumber)drive));
1.1413 + TEST2(err, KErrNone);
1.1414 + //Verify the content of the restored file
1.1415 + err = parse.Set(KTestFile2, &driveName, 0);
1.1416 + TEST2(err, KErrNone);
1.1417 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), parse.FullName(), EFileRead | EFileWrite);
1.1418 + TEST2(err, KErrNone);
1.1419 + TBuf8<50> data;
1.1420 + err = file.Read(data);
1.1421 + TEST2(err, KErrNone);
1.1422 + file.Close();
1.1423 + TEST(data == KData1);
1.1424 + //Verify the content of the file on drive KTestDrive. It should be the same as before the backup&restore.
1.1425 + err = parse.Set(KTestFile2, &driveNameDefault, 0);
1.1426 + TEST2(err, KErrNone);
1.1427 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), parse.FullName(), EFileRead | EFileWrite);
1.1428 + TEST2(err, KErrNone);
1.1429 + err = file.Read(data);
1.1430 + TEST2(err, KErrNone);
1.1431 + file.Close();
1.1432 + TEST(data == KData2);
1.1433 + //Cleanup
1.1434 + err = parse.Set(KTestFile2, &driveNameDefault, 0);
1.1435 + TEST2(err, KErrNone);
1.1436 + (void)TheSqlSrvTestBurInterface->Fs().Delete(parse.FullName());
1.1437 + err = parse.Set(KTestFile2, &driveName, 0);
1.1438 + TEST2(err, KErrNone);
1.1439 + (void)TheSqlSrvTestBurInterface->Fs().Delete(parse.FullName());
1.1440 + break;
1.1441 + }
1.1442 + delete backupClient;
1.1443 + if(drive > EDriveZ)
1.1444 + {
1.1445 + TheTest.Printf(_L("No R/W drive has been found, different than %S\r\n"), &driveNameDefault);
1.1446 + }
1.1447 + }
1.1448 +
1.1449 +/**
1.1450 +@SYMTestCaseID PDS-SQL-UT-4229
1.1451 +@SYMTestCaseDesc SQL Backup&Restore with locked file.
1.1452 + The test creates two test files on the same drive and with the same uid.
1.1453 + Then the test backups the databases. After the backup the test simulates that
1.1454 + the first file is "in use". Then the test performs a restore.
1.1455 + The expected result: the locked file is not restored but the other file is restored.
1.1456 +@SYMTestActions SQL Backup&Restore with locked file.
1.1457 +@SYMTestExpectedResults Test must not fail
1.1458 +@SYMTestPriority High
1.1459 +*/
1.1460 +void LockFileTest()
1.1461 + {
1.1462 + CSqlBurCallback* backupClient = NULL;
1.1463 + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.1464 + TEST2(err, KErrNone);
1.1465 + TEST(backupClient != NULL);
1.1466 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile3);
1.1467 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile4);
1.1468 + //Create the files. File 1.
1.1469 + RFile file;
1.1470 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile3, EFileRead | EFileWrite);
1.1471 + TEST2(err, KErrNone);
1.1472 + _LIT8(KData1, "123456787989");
1.1473 + err = file.Write(KData1);
1.1474 + TEST2(err, KErrNone);
1.1475 + err = file.Flush();
1.1476 + TEST2(err, KErrNone);
1.1477 + file.Close();
1.1478 + //...file 2
1.1479 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile4, EFileRead | EFileWrite);
1.1480 + TEST2(err, KErrNone);
1.1481 + _LIT8(KData2, "ABCDEF");
1.1482 + err = file.Write(KData2);
1.1483 + TEST2(err, KErrNone);
1.1484 + err = file.Flush();
1.1485 + TEST2(err, KErrNone);
1.1486 + file.Close();
1.1487 + //Backup
1.1488 + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid3, KTestDrive));
1.1489 + TEST2(err, KErrNone);
1.1490 + //Modify the files. Keep the first file opened.
1.1491 + RFile file1;
1.1492 + err = file1.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile3, EFileRead | EFileWrite);
1.1493 + TEST2(err, KErrNone);
1.1494 + _LIT8(KData3, "YYYYYQQQQQQQQQQQ");
1.1495 + err = file1.Write(KData3);
1.1496 + TEST2(err, KErrNone);
1.1497 + err = file1.Flush();
1.1498 + TEST2(err, KErrNone);
1.1499 + //...file 2
1.1500 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile4, EFileRead | EFileWrite);
1.1501 + TEST2(err, KErrNone);
1.1502 + _LIT8(KData4, "5545495444j32322332234223432");
1.1503 + err = file.Write(KData4);
1.1504 + TEST2(err, KErrNone);
1.1505 + err = file.Flush();
1.1506 + TEST2(err, KErrNone);
1.1507 + file.Close();
1.1508 + //Restore. The reported error should be KErrInUse.
1.1509 + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid3, KTestDrive));
1.1510 + TEST2(err, KErrInUse);
1.1511 + //Close file 1 and check the content. It should be the same as after the backup
1.1512 + file1.Close();
1.1513 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile3, EFileRead | EFileWrite);
1.1514 + TEST2(err, KErrNone);
1.1515 + TBuf8<50> data;
1.1516 + err = file.Read(data);
1.1517 + TEST2(err, KErrNone);
1.1518 + file.Close();
1.1519 + TEST(data == KData3);
1.1520 + //File2: check the content. It should be the same as before the backup
1.1521 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile4, EFileRead | EFileWrite);
1.1522 + TEST2(err, KErrNone);
1.1523 + err = file.Read(data);
1.1524 + TEST2(err, KErrNone);
1.1525 + file.Close();
1.1526 + TEST(data == KData2);
1.1527 + //
1.1528 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile4);
1.1529 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile3);
1.1530 + delete backupClient;
1.1531 + }
1.1532 +
1.1533 +/**
1.1534 +@SYMTestCaseID PDS-SQL-UT-4230
1.1535 +@SYMTestCaseDesc SQL Backup&Restore with locked file - test 2.
1.1536 + The test creates two test files on the same drive and with different uids.
1.1537 + Then the test backups the databases. After the backup the test simulates that
1.1538 + the first file is "in use". Then the test performs a restore.
1.1539 + The expected result: the locked file is not restored but the other file is restored.
1.1540 +@SYMTestActions SQL Backup&Restore with locked file - test 2.
1.1541 +@SYMTestExpectedResults Test must not fail
1.1542 +@SYMTestPriority High
1.1543 +*/
1.1544 +void LockFileTest2()
1.1545 + {
1.1546 + CSqlBurCallback* backupClient = NULL;
1.1547 + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.1548 + TEST2(err, KErrNone);
1.1549 + TEST(backupClient != NULL);
1.1550 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);//KTestClientUid1 used
1.1551 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile4);//KTestClientUid3 used
1.1552 + //Create the files. File 1.
1.1553 + RFile file;
1.1554 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite);
1.1555 + TEST2(err, KErrNone);
1.1556 + _LIT8(KData1, "123456787989");
1.1557 + err = file.Write(KData1);
1.1558 + TEST2(err, KErrNone);
1.1559 + err = file.Flush();
1.1560 + TEST2(err, KErrNone);
1.1561 + file.Close();
1.1562 + //...file 2
1.1563 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile4, EFileRead | EFileWrite);
1.1564 + TEST2(err, KErrNone);
1.1565 + _LIT8(KData2, "ABCDEF");
1.1566 + err = file.Write(KData2);
1.1567 + TEST2(err, KErrNone);
1.1568 + err = file.Flush();
1.1569 + TEST2(err, KErrNone);
1.1570 + file.Close();
1.1571 + //Backup
1.1572 + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive));
1.1573 + TEST2(err, KErrNone);
1.1574 + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid3, KTestDrive));
1.1575 + TEST2(err, KErrNone);
1.1576 + //Modify the files. Keep the first file opened.
1.1577 + RFile file1;
1.1578 + err = file1.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite);
1.1579 + TEST2(err, KErrNone);
1.1580 + _LIT8(KData3, "YYYYYQQQQQQQQQQQ");
1.1581 + err = file1.Write(KData3);
1.1582 + TEST2(err, KErrNone);
1.1583 + err = file1.Flush();
1.1584 + TEST2(err, KErrNone);
1.1585 + //...file 2
1.1586 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile4, EFileRead | EFileWrite);
1.1587 + TEST2(err, KErrNone);
1.1588 + _LIT8(KData4, "5545495444j32322332234223432");
1.1589 + err = file.Write(KData4);
1.1590 + TEST2(err, KErrNone);
1.1591 + err = file.Flush();
1.1592 + TEST2(err, KErrNone);
1.1593 + file.Close();
1.1594 + //Restore the first file. The reported error should be KErrInUse.
1.1595 + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive));
1.1596 + TEST2(err, KErrInUse);
1.1597 + //Restore the second file. The reported error should be KErrNone.
1.1598 + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid3, KTestDrive));
1.1599 + TEST2(err, KErrNone);
1.1600 + //Close file 1 and check the content. It should be the same as after the backup
1.1601 + file1.Close();
1.1602 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite);
1.1603 + TEST2(err, KErrNone);
1.1604 + TBuf8<50> data;
1.1605 + err = file.Read(data);
1.1606 + TEST2(err, KErrNone);
1.1607 + file.Close();
1.1608 + TEST(data == KData3);
1.1609 + //File2: check the content. It should be the same as before the backup
1.1610 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KTestFile4, EFileRead | EFileWrite);
1.1611 + TEST2(err, KErrNone);
1.1612 + err = file.Read(data);
1.1613 + TEST2(err, KErrNone);
1.1614 + file.Close();
1.1615 + TEST(data == KData2);
1.1616 + //
1.1617 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile4);
1.1618 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);
1.1619 + delete backupClient;
1.1620 + }
1.1621 +
1.1622 +CDir* GetPrivateDirContent(TDriveNumber aDrive)
1.1623 + {
1.1624 + TDriveUnit driveUnit(aDrive);
1.1625 + TDriveName driveName = driveUnit.Name();
1.1626 + TFileName path;
1.1627 + path.Copy(driveName);
1.1628 + path.Append(KPrivateDir);
1.1629 + _LIT(KMatchAllDbFiles, "*");
1.1630 + path.Append(KMatchAllDbFiles);
1.1631 + //Do the search
1.1632 + CDir* fileNameCol = NULL;
1.1633 + TInt err = TheSqlSrvTestBurInterface->Fs().GetDir(path, KEntryAttNormal, ESortByName, fileNameCol);
1.1634 + TEST2(err, KErrNone);
1.1635 + return fileNameCol;
1.1636 + }
1.1637 +
1.1638 +/**
1.1639 +@SYMTestCaseID PDS-SQL-UT-4231
1.1640 +@SYMTestCaseDesc SQL Backup&Restore - directory content test.
1.1641 + The test stores into an array information regarding all files in
1.1642 + SQL private datacage. Then the test backups one of the files and modifies
1.1643 + the file after that. Then the test does a restore. Expected result - the only
1.1644 + modifed file should be the file which was sent for backup.
1.1645 +@SYMTestActions SQL Backup&Restore - directory content test.
1.1646 +@SYMTestExpectedResults Test must not fail
1.1647 +@SYMTestPriority High
1.1648 +*/
1.1649 +void DirectoryContentTest()
1.1650 + {
1.1651 + CSqlBurCallback* backupClient = NULL;
1.1652 + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.1653 + TEST2(err, KErrNone);
1.1654 + TEST(backupClient != NULL);
1.1655 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);//KTestClientUid1 used
1.1656 + //Create the file
1.1657 + RFile file;
1.1658 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite);
1.1659 + TEST2(err, KErrNone);
1.1660 + _LIT8(KData1, "123456787989");
1.1661 + err = file.Write(KData1);
1.1662 + TEST2(err, KErrNone);
1.1663 + err = file.Flush();
1.1664 + TEST2(err, KErrNone);
1.1665 + file.Close();
1.1666 + //Store file entries into an array
1.1667 + CDir* dirBeforeBackup = GetPrivateDirContent(KTestDrive);
1.1668 + //Backup
1.1669 + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive));
1.1670 + TEST2(err, KErrNone);
1.1671 + //Check dir content
1.1672 + CDir* dirAfterBackup = GetPrivateDirContent(KTestDrive);
1.1673 + TEST2(dirBeforeBackup->Count(), dirAfterBackup->Count());
1.1674 + for(TInt i=0;i<dirBeforeBackup->Count();++i)
1.1675 + {
1.1676 + const TEntry& entry1 = (*dirBeforeBackup)[i];
1.1677 + const TEntry& entry2 = (*dirAfterBackup)[i];
1.1678 + TheTest.Printf(_L("Entry1=%S, Entry2=%S\r\n"), &entry1.iName, &entry2.iName);
1.1679 + TBool rc = entry1.iAtt == entry2.iAtt;
1.1680 + TEST(rc);
1.1681 + rc = entry1.iSize == entry2.iSize;
1.1682 + TEST(rc);
1.1683 + rc = entry1.iModified == entry2.iModified;
1.1684 + TEST(rc);
1.1685 + rc = entry1.iType == entry2.iType;
1.1686 + TEST(rc);
1.1687 + rc = entry1.iName == entry2.iName;
1.1688 + TEST(rc);
1.1689 + }
1.1690 + delete dirAfterBackup;
1.1691 + //Modify the file
1.1692 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite);
1.1693 + TEST2(err, KErrNone);
1.1694 + _LIT8(KData2, "ABCDEF");
1.1695 + err = file.Write(KData2);
1.1696 + TEST2(err, KErrNone);
1.1697 + err = file.Flush();
1.1698 + TEST2(err, KErrNone);
1.1699 + file.Close();
1.1700 + //Restore
1.1701 + User::After(2000000);//To force a change in the file time stamp (the restored file time stamp).
1.1702 + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive));
1.1703 + TEST2(err, KErrNone);
1.1704 + //Check dir content
1.1705 + CDir* dirAfterRestore = GetPrivateDirContent(KTestDrive);
1.1706 + TEST2(dirBeforeBackup->Count(), dirAfterRestore->Count());
1.1707 + for(TInt i=0;i<dirBeforeBackup->Count();++i)
1.1708 + {
1.1709 + const TEntry& entry1 = (*dirBeforeBackup)[i];
1.1710 + const TEntry& entry2 = (*dirAfterRestore)[i];
1.1711 + TheTest.Printf(_L("Entry1=%S, Entry2=%S\r\n"), &entry1.iName, &entry2.iName);
1.1712 + TBool rc = entry1.iAtt == entry2.iAtt;
1.1713 + TEST(rc);
1.1714 + rc = entry1.iSize == entry2.iSize;
1.1715 + TEST(rc);
1.1716 + if(entry1.iName.FindF(KTestFile1NameOnly) >= 0)
1.1717 + {
1.1718 + rc = entry1.iModified != entry2.iModified;
1.1719 + }
1.1720 + else
1.1721 + {
1.1722 + rc = entry1.iModified == entry2.iModified;
1.1723 + }
1.1724 + TEST(rc);
1.1725 + rc = entry1.iType == entry2.iType;
1.1726 + TEST(rc);
1.1727 + rc = entry1.iName == entry2.iName;
1.1728 + TEST(rc);
1.1729 + }
1.1730 + delete dirAfterRestore;
1.1731 + //
1.1732 + delete dirBeforeBackup;
1.1733 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);
1.1734 + delete backupClient;
1.1735 + }
1.1736 +
1.1737 +/**
1.1738 +@SYMTestCaseID PDS-SQL-UT-4232
1.1739 +@SYMTestCaseDesc SQL Backup&Restore - large file test.
1.1740 + Backup and restore with a file with size bigger than 1 Mb.
1.1741 +@SYMTestActions SQL Backup&Restore - large file test.
1.1742 +@SYMTestExpectedResults Test must not fail
1.1743 +@SYMTestPriority High
1.1744 +*/
1.1745 +void LargeFileTest()
1.1746 + {
1.1747 + CSqlBurCallback* backupClient = NULL;
1.1748 + TRAPD(err, backupClient = CSqlBurCallback::NewL(*TheSqlSrvTestBurInterface));
1.1749 + TEST2(err, KErrNone);
1.1750 + TEST(backupClient != NULL);
1.1751 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);//KTestClientUid1 used
1.1752 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile2);//KTestClientUid2 used
1.1753 + //Allocate buffer for the data
1.1754 + const TInt KDataBufSize = 100000;
1.1755 + HBufC8* dataBuf = HBufC8::New(KDataBufSize);
1.1756 + TEST(dataBuf != NULL);
1.1757 + TPtr8 dataPtr = dataBuf->Des();
1.1758 + //Create file 1
1.1759 + const TInt KFileSize1 = 1201345;
1.1760 + RFile file;
1.1761 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile1, EFileRead | EFileWrite);
1.1762 + TEST2(err, KErrNone);
1.1763 + dataPtr.SetLength(dataPtr.MaxLength());
1.1764 + const TChar KChar1(0x5A);
1.1765 + dataPtr.Fill(KChar1);
1.1766 + TInt len = KFileSize1;
1.1767 + while(len > 0)
1.1768 + {
1.1769 + TInt blockSize = Min(len, dataPtr.MaxLength());
1.1770 + err = file.Write(dataPtr, blockSize);
1.1771 + TEST2(err, KErrNone);
1.1772 + len -= blockSize;
1.1773 + }
1.1774 + err = file.Flush();
1.1775 + TEST2(err, KErrNone);
1.1776 + file.Close();
1.1777 + //Create file 2
1.1778 + const TInt KFileSize2 = 1387651;
1.1779 + err = file.Replace(TheSqlSrvTestBurInterface->Fs(), KTestFile2, EFileRead | EFileWrite);
1.1780 + TEST2(err, KErrNone);
1.1781 + dataPtr.SetLength(dataPtr.MaxLength());
1.1782 + const TChar KChar2(0xD5);
1.1783 + dataPtr.Fill(KChar2);
1.1784 + len = KFileSize2;
1.1785 + while(len > 0)
1.1786 + {
1.1787 + TInt blockSize = Min(len, dataPtr.MaxLength());
1.1788 + err = file.Write(dataPtr, blockSize);
1.1789 + TEST2(err, KErrNone);
1.1790 + len -= blockSize;
1.1791 + }
1.1792 + err = file.Flush();
1.1793 + TEST2(err, KErrNone);
1.1794 + file.Close();
1.1795 + //Backup
1.1796 + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive));
1.1797 + TEST2(err, KErrNone);
1.1798 + TRAP(err, TestBackupL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid2, KTestDrive));
1.1799 + TEST2(err, KErrNone);
1.1800 + //Delete the files
1.1801 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);
1.1802 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile2);
1.1803 + //Restore
1.1804 + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid1, KTestDrive));
1.1805 + TEST2(err, KErrNone);
1.1806 + TRAP(err, TestRestoreL(*backupClient, TheSqlSrvTestBurInterface->Fs(), KTestClientUid2, KTestDrive));
1.1807 + TEST2(err, KErrNone);
1.1808 + //Check restored files content
1.1809 + const TPtrC KFileNames[] = {KTestFile1(), KTestFile2()};
1.1810 + const TInt KFileSizes[] = {KFileSize1, KFileSize2};
1.1811 + const TChar KSymbols[] = {KChar1, KChar2};
1.1812 + for(TInt i=0;i<(sizeof(KFileNames)/sizeof(KFileNames[i]));++i)
1.1813 + {
1.1814 + err = file.Open(TheSqlSrvTestBurInterface->Fs(), KFileNames[i], EFileRead);
1.1815 + TEST2(err, KErrNone);
1.1816 + len = 0;
1.1817 + err = file.Size(len);
1.1818 + TEST2(err, KErrNone);
1.1819 + TEST2(len, KFileSizes[i]);
1.1820 + while(len > 0)
1.1821 + {
1.1822 + TInt blockSize = Min(len, dataPtr.MaxLength());
1.1823 + err = file.Read(dataPtr, blockSize);
1.1824 + TEST2(err, KErrNone);
1.1825 + len -= blockSize;
1.1826 + for(TInt j=0;j<dataPtr.Length();++j)
1.1827 + {
1.1828 + TEST(dataPtr[j] == KSymbols[i]);
1.1829 + }
1.1830 + }
1.1831 + file.Close();
1.1832 + }
1.1833 + //
1.1834 + delete dataBuf;
1.1835 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile2);
1.1836 + (void)TheSqlSrvTestBurInterface->Fs().Delete(KTestFile1);
1.1837 + delete backupClient;
1.1838 + }
1.1839 +
1.1840 +void DoMain()
1.1841 + {
1.1842 + TestEnvCreate();
1.1843 +
1.1844 + TheTest.Start(_L("Store db content to memory buffer"));
1.1845 + StoreDbContentToBuf(TheSqlSrvTestBurInterface->Fs(), KTestDrive, KClientUid);
1.1846 +
1.1847 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4002 Backup: functional test "));
1.1848 + FunctionalTest();
1.1849 +
1.1850 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4003 Backup: OOM test "));
1.1851 + OomTest();
1.1852 +
1.1853 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4143 Backup&Restore: functional test 2"));
1.1854 + FunctionalTest2();
1.1855 +
1.1856 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4144 Backup&Restore: legacy file format test"));
1.1857 + LegacyFileFormatTest();
1.1858 +
1.1859 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4192 Backup&Restore: empty backup file list"));
1.1860 + EmptyBackupFileListTest();
1.1861 +
1.1862 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4193 Backup: File I/O error simulation test"));
1.1863 + BackupRestoreFileIoErrTest();
1.1864 +
1.1865 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4225 Zero size file - backup test"));
1.1866 + BackupZeroSizeFileTest();
1.1867 +
1.1868 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4226 Restore test - corrupted archive 1"));
1.1869 + CorruptedArchiveTest1();
1.1870 +
1.1871 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4227 Restore test - corrupted archive 2"));
1.1872 + CorruptedArchiveTest2();
1.1873 +
1.1874 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4228 Backup&Restore test on a drive different than KTestDrive (C: by default)"));
1.1875 + DbDriveTest();
1.1876 +
1.1877 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4229 Backup&Restore test with locked file"));
1.1878 + LockFileTest();
1.1879 +
1.1880 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4230 Backup&Restore test with locked file 2"));
1.1881 + LockFileTest2();
1.1882 +
1.1883 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4231 Backup&Restore - directory content test"));
1.1884 + DirectoryContentTest();
1.1885 +
1.1886 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4232 Backup&Restore - large file test"));
1.1887 + LargeFileTest();
1.1888 +
1.1889 + TestEnvDestroy();
1.1890 + }
1.1891 +
1.1892 +TInt E32Main()
1.1893 + {
1.1894 + TheTest.Title();
1.1895 +
1.1896 + CTrapCleanup* tc = CTrapCleanup::New();
1.1897 + TheTest(tc != NULL);
1.1898 +
1.1899 + __UHEAP_MARK;
1.1900 +
1.1901 + DoMain();
1.1902 +
1.1903 + __UHEAP_MARKEND;
1.1904 +
1.1905 + TheTest.End();
1.1906 + TheTest.Close();
1.1907 +
1.1908 + delete tc;
1.1909 +
1.1910 + User::Heap().Check();
1.1911 + return KErrNone;
1.1912 + }