installationservices/swtransactionservices/test/tintegrityservices/source/tintegrityservicesstep.cpp
/*
* Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
/**
@file
@test
@internalTechnology
*/
#include "tintegrityservicesstep.h"
#include <s32file.h>
#include "journal.h"
#include "journalfile.h"
/////////////////////////////////////////////////////////////////////
// CIntegrityServicesStep
/////////////////////////////////////////////////////////////////////
CIntegrityServicesStepBase::CIntegrityServicesStepBase(CStsTestServer &aStsTestServer):CStsBaseTestStep(aStsTestServer)
{
}
void CIntegrityServicesStepBase::ImplTestStepPreambleL()
{
INFO_PRINTF1(_L("CIntegrityServicesStepBase::ImplTestStepPreambleL()"));
__UHEAP_MARK;
// Install an active scheduler
CActiveScheduler* s = new (ELeave) CActiveScheduler;
s->Install(s);
User::LeaveIfError(iIntegritySession.Connect());
ReadFailureSettingsL();
}
void CIntegrityServicesStepBase::ImplTestStepPostambleL()
{
INFO_PRINTF1(_L("CIntegrityServicesStepBase::ImplTestStepPostambleL()"));
// Remove the installed active scheduler
CActiveScheduler* s = CActiveScheduler::Current();
s->Install(NULL);
delete s;
iIntegritySession.Close();
__UHEAP_MARKEND;
}
void CIntegrityServicesStepBase::GetStringArrayFromConfigL(const TDesC& aSectName, const TDesC& aKeyName, RArray<TPtrC>& aArray)
{
INFO_PRINTF1(_L("CIntegrityServicesStepBase::GetStringArrayFromConfigL()"));
_LIT(KKeyFormat, "-%02d");
HBufC* buf = HBufC::NewLC(aKeyName.Length() + KKeyFormat().Length());
TPtr ptr(buf->Des());
INFO_PRINTF2(_L("Parsing attribute: %S"), &aKeyName);
TInt i = 0;
TBool cont = ETrue;
do
{
++i;
ptr = aKeyName;
ptr.AppendFormat(KKeyFormat(), i);
TPtrC val;
cont = GetStringFromConfig(aSectName, ptr, val);
if (cont)
{
User::LeaveIfError(aArray.Append(val));
}
} while (cont);
INFO_PRINTF2(_L("Element count: %d"), i-1);
CleanupStack::PopAndDestroy(buf);
}
TBool CIntegrityServicesStepBase::CheckFilesL()
{
INFO_PRINTF1(_L("CIntegrityServicesStepBase::CheckFilesL()"));
TInt result = ETrue;
RArray<TPtrC> fileArray;
CleanupClosePushL(fileArray);
GetStringArrayFromConfigL(ConfigSection(), KPresent, fileArray);
for (TInt file = 0; file < fileArray.Count();file++)
{
if(FileExistsL(fileArray[file]))
{
INFO_PRINTF2(_L("%S was found"), &fileArray[file]);
}
else
{
ERR_PRINTF2(_L("%S was not found"), &fileArray[file]);
result = EFalse;
}
}
fileArray.Reset();
GetStringArrayFromConfigL(ConfigSection(), KAbsent, fileArray);
for (TInt file = 0; file < fileArray.Count();file++)
{
if(FileExistsL(fileArray[file]))
{
ERR_PRINTF2(_L("%S was found"), &fileArray[file]);
result = EFalse;
}
else
{
INFO_PRINTF2(_L("%S was not found"), &fileArray[file]);
}
}
fileArray.Reset();
CleanupStack::PopAndDestroy(&fileArray);
return result;
}
void CIntegrityServicesStepBase::ReadFailureSettingsL()
{
INFO_PRINTF1(_L("CIntegrityServicesStepBase::ReadFailureSettings()"));
TPtrC failType;
if(!GetStringFromConfig(ConfigSection(), KFailType, failType))
{
failType.Set(KNullDesC);
}
TPtrC failPosition;
if(!GetStringFromConfig(ConfigSection(), KFailPosition, failPosition))
{
failPosition.Set(KNullDesC);
}
TPtrC failFileName;
if(!GetStringFromConfig(ConfigSection(), KFailFileName, failFileName))
{
failFileName.Set(KNullDesC);
}
iIntegritySession.SetSimulatedFailureL(failType, failPosition, failFileName);
}
void CIntegrityServicesStepBase::doInstallL()
{
INFO_PRINTF1(_L("CIntegrityServicesStepBase::doInstallL()"));
RArray<TPtrC> fileArray;
CleanupClosePushL(fileArray);
GetStringArrayFromConfigL(ConfigSection(), KRemoveFile, fileArray);
for (TInt file = 0; file < fileArray.Count();file++)
{
INFO_PRINTF2(_L("RemovingFile: %S"), &fileArray[file]);
iIntegritySession.RemoveL(fileArray[file]);
}
fileArray.Reset();
GetStringArrayFromConfigL(ConfigSection(), KAddFile, fileArray);
for (TInt file = 0; file < fileArray.Count();file++)
{
INFO_PRINTF2(_L("AddingFile: %S"), &fileArray[file]);
iIntegritySession.AddL(fileArray[file]);
iIntegritySession.CreateNewTestFileL(fileArray[file]);
}
fileArray.Reset();
GetStringArrayFromConfigL(ConfigSection(), KTempFile, fileArray);
for (TInt file = 0; file < fileArray.Count();file++)
{
INFO_PRINTF2(_L("TemporaryFile: %S"), &fileArray[file]);
iIntegritySession.TemporaryL(fileArray[file]);
iIntegritySession.CreateTempTestFileL(fileArray[file]);
}
fileArray.Reset();
RArray<TPtrC> operationArray;
CleanupClosePushL(operationArray);
GetStringArrayFromConfigL(ConfigSection(), KArbitraryOpFile, fileArray);
GetStringArrayFromConfigL(ConfigSection(), KOperation, operationArray);
TInt fileCount = fileArray.Count();
if (fileCount != operationArray.Count())
{
ERR_PRINTF3(_L("Number of files (%d) does not match number of operations (%d)"), fileCount, operationArray.Count());
SetTestStepResult(EFail);
}
else
{
for (TInt file = 0; file < fileCount;file++)
{
if (operationArray[file].CompareF(KAddFile) == 0)
{
INFO_PRINTF2(_L("AddingFile: %S"), &fileArray[file]);
iIntegritySession.AddL(fileArray[file]);
iIntegritySession.CreateNewTestFileL(fileArray[file]);
}
else if (operationArray[file].CompareF(KRemoveFile) == 0)
{
INFO_PRINTF2(_L("RemovingFile: %S"), &fileArray[file]);
iIntegritySession.RemoveL(fileArray[file]);
}
else if (operationArray[file].CompareF(KTempFile) == 0)
{
INFO_PRINTF2(_L("TemporaryFile: %S"), &fileArray[file]);
iIntegritySession.TemporaryL(fileArray[file]);
iIntegritySession.CreateTempTestFileL(fileArray[file]);
}
else
{
ERR_PRINTF3(_L("Operation %S not understood, skipping file %S"), &operationArray[file], &fileArray[file]);
}
}
}
CleanupStack::PopAndDestroy(2, &fileArray);
iIntegritySession.CommitL();
}
void CIntegrityServicesStepBase::doRecoverL()
{
INFO_PRINTF1(_L("CIntegrityServicesStepBase::doRecoverL()"));
iIntegritySession.RollBackL(EFalse);
}
void CIntegrityServicesStepBase::doCleanupL()
{
INFO_PRINTF1(_L("CIntegrityServicesStepBase::doCleanupL()"));
RArray<TPtrC> fileArray;
CleanupClosePushL(fileArray);
GetStringArrayFromConfigL(ConfigSection(), KCleanupFile, fileArray);
for (TInt file = 0; file < fileArray.Count();file++)
{
TRAPD(err, DeleteFileL(fileArray[file]));
if(err != KErrNone && err != KErrPathNotFound && err != KErrNotFound)
{
User::Leave(err);
}
}
fileArray.Reset();
GetStringArrayFromConfigL(ConfigSection(), KCleanupDirectory, fileArray);
for (TInt file = 0; file < fileArray.Count();file++)
{
TRAPD(err, DeleteFileL(fileArray[file]));
if(err != KErrNone && err != KErrPathNotFound && err != KErrNotFound)
{
User::Leave(err);
}
}
fileArray.Reset();
CleanupStack::PopAndDestroy(&fileArray);
}
/////////////////////////////////////////////////////////////////////
// CInstallStep
/////////////////////////////////////////////////////////////////////
CInstallStep::CInstallStep(CStsTestServer &aStsTestServer):CIntegrityServicesStepBase(aStsTestServer)
{
SetTestStepName(KInstall);
}
void CInstallStep::ImplTestStepL()
{
INFO_PRINTF1(_L("CInstallStep::ImplTestStepL()"));
TRAPD(err, doInstallL());
if(err == KErrNone || err == KIntegrityServicesSimulatedBatteryFailure)
{
if(CheckFilesL())
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
else
{
User::Leave(err);
}
}
/////////////////////////////////////////////////////////////////////
// CRecoverStep
/////////////////////////////////////////////////////////////////////
CRecoverStep::CRecoverStep(CStsTestServer &aStsTestServer):CIntegrityServicesStepBase(aStsTestServer)
{
SetTestStepName(KRecover);
}
void CRecoverStep::ImplTestStepL()
{
INFO_PRINTF1(_L("CRecoverStep::ImplTestStepL()"));
// begin recovery
TRAPD(err, doRecoverL());
if(err == KErrNone || err == KIntegrityServicesSimulatedBatteryFailure)
{
if(CheckFilesL())
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
else
{
User::Leave(err);
}
}
/////////////////////////////////////////////////////////////////////
// CCleanupStep
/////////////////////////////////////////////////////////////////////
CCleanupStep::CCleanupStep(CStsTestServer &aStsTestServer):CIntegrityServicesStepBase(aStsTestServer)
{
SetTestStepName(KCleanup);
}
void CCleanupStep::ImplTestStepL()
{
INFO_PRINTF1(_L("CCleanupStep::ImplTestStepL()"));
doCleanupL();
SetTestStepResult(EPass);
}
/////////////////////////////////////////////////////////////////////
// CRecoverStep
/////////////////////////////////////////////////////////////////////
CCheckStep::CCheckStep(CStsTestServer &aStsTestServer):CIntegrityServicesStepBase(aStsTestServer)
{
SetTestStepName(KCheck);
}
void CCheckStep::ImplTestStepL()
{
INFO_PRINTF1(_L("CCheckStep::ImplTestStepL()"));
// Just check for files
if(CheckFilesL())
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
//---------- new unit tests developed as part of the STS framework ----------
using namespace Usif;
//define event names for logging purposes (used in journal file unit tests and journal unit tests
_LIT(KENone, "ENone");
_LIT(KERemovedFile,"ERemovedFile");
_LIT(KEBackupFile,"EBackupFile");
_LIT(KETempFile,"ETempFile");
_LIT(KEAddedFile,"EAddedFile");
_LIT(KECommitted,"ECommitted");
_LIT(KEBackupFilesRemoved,"EBackupFilesRemoved");
_LIT(KEAddedFilesRemoved,"EAddedFilesRemoved");
_LIT(KERemovedFilesRestored,"ERemovedFilesRestored");
_LIT(KETempFilesRemoved, "ETempFilesRemoved");
const TDesC* eventNames[] = {
&KENone,
&KERemovedFile,
&KEBackupFile,
&KETempFile,
&KEAddedFile,
&KECommitted,
&KEBackupFilesRemoved,
&KEAddedFilesRemoved,
&KERemovedFilesRestored,
&KETempFilesRemoved
};
const TFileMode defaultJournalFileMode = TFileMode (TFileMode(EFileWrite) | TFileMode(EFileShareAny));
CJournalFileUnitTest::CJournalFileUnitTest(CStsTestServer &aStsTestServer): CStsBaseTestStep(aStsTestServer)
{
// Call base class method to set up the human readable name for logging
SetTestStepName(KJournalFileUnitTest);
}
CJournalFileUnitTest::~CJournalFileUnitTest()
{
delete testJournalFile;
iFs.Close();
iLoader.Close();
}
void CJournalFileUnitTest::ImplTestStepPreambleL()
/**
@return - void code
Override of base class virtual
*/
{
INFO_PRINTF1(_L("JournalFileUnitTest Preamble"));
User::LeaveIfError(iFs.Connect());
User::LeaveIfError(iLoader.Connect());
testJournalFile = CTestFile::NewL(iFs);
SetTestStepResult(EPass);
}
void CJournalFileUnitTest::ImplTestStepL()
/**
@return - void code
Override of base class pure virtual
*/
{
INFO_PRINTF1(_L("JournalFileUnitTest in test step"));
SetTestStepResult(EPass);
TPtrC journalFilePathInIni = GetTargetFilePathFromConfigL();
TParsePtrC journalFilePathParse(journalFilePathInIni);
TDriveUnit journaldrive(journalFilePathParse.Drive());
HBufC* targetFileName = HBufC::NewLC(KMaxFileName);
HBufC* backupFileName = HBufC::NewLC(KMaxFileName);
CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
//feed incorrect file to the journalfile (ie: file's on other drive)
TPtr targetFileNameBasePtr(targetFileName->Des());
targetFileNameBasePtr.Append(TDriveUnit(journaldrive+1).Name());
targetFileNameBasePtr.Append(journalFilePathParse.Path());
TPtr targetFileNamePtr(targetFileNameBasePtr);
targetFileNamePtr.Append(_L("dummyadd.txt"));
TPtr targetBackupFileNamePtr(backupFileName->Des());
TInt err(0);
TInt seekPosition(0);
TInt seekToEndPosition(0);
TIntValue intValue = {0};
TIntValue extraByte = {0xFF};
TRAP(err, journalFile->AddL(targetFileNamePtr));
if(err!=KErrBadName)
{
ERR_PRINTF2(_L("<font color=red>CJournalFile::AddL() returned incorrect error code. KErrBadName is expected %d is returned!</font>"), err);
SetTestStepResult(EFail);
}
targetFileNamePtr.Set(targetFileNameBasePtr);
targetFileNamePtr.Append(_L("dummytemp.txt"));
TRAP(err, journalFile->TemporaryL(targetFileNamePtr));
if(err!=KErrBadName)
{
ERR_PRINTF2(_L("<font color=red>CJournalFile::RemoveL() returned incorrect error code. KErrBadName is expected %d is returned!</font>"), err);
SetTestStepResult(EFail);
}
targetFileNamePtr.Set(targetFileNameBasePtr);
targetFileNamePtr.Append(_L("dummyremove.txt"));
TRAP(err, journalFile->RemoveL(targetFileNamePtr, targetBackupFileNamePtr));
if(err!=KErrBadName)
{
ERR_PRINTF2(_L("<font color=red>CJournalFile::RemoveL() returned incorrect error code. KErrBadName is expected %d is returned!</font>"), err);
SetTestStepResult(EFail);
}
*targetFileName = KEmptyString;
targetFileNameBasePtr.Set(targetFileName->Des());
targetFileNameBasePtr.Append(journalFilePathParse.DriveAndPath());
CleanupStack::PopAndDestroy(journalFile);
DeleteFileL(journalFilePathInIni);
//-------------------------------------------------------------------------------------
//Steps:
// 1.) create a CJournalFile object
// 2.) set last event by invoking CJournalFile::EventL() (this sets the iLastEvent as well as writes the event value to the journal file on disk)
// 3.) destroy object
// 4.) corrupt information by overwriting the event value in the file to requested invalid value
// 5.) recreate CjournalFile object -> this will trigger CJournalFile::ReadEntryL
// note: the purpose of this testcase to excersise the main switch-case in CJournalFile::ReadEntryL
//-------------------------------------------------------------------------------------
TIntegrityServicesEvent eventsToSet[] = {ERemovedFile,
EBackupFile,
ETempFile,
EAddedFile,
ECommitted,
EBackupFilesRemoved,
EAddedFilesRemoved,
//ETempFilesRemoved,
ERemovedFilesRestored,
};
TInt numOfInvalidEvents[] = {6, //number of invalid events for ERemovedFile
1, //number of invalid events for EBackupFile
6, //number of invalid events for ETempFile
6, //number of invalid events for EAddedFile
7, //number of invalid events for ECommitted
9, //number of invalid events for EBackupFilesRemoved
6, //number of invalid events for EAddedFilesRemoved
//ETempFilesRemoved
9 //number of invalid events for ERemovedFilesRestored
};
TIntegrityServicesEvent invalidEvents[][10] = {{EBackupFile, ECommitted, EBackupFilesRemoved, EAddedFilesRemoved, ERemovedFilesRestored, ETempFilesRemoved}, //invalid events for ERemovedFile
{EBackupFile}, //invalid events for EBackupFile, this is not really invalid value for EBackupFile, actually EBackupFile itself is invalid on its own in the file
{EBackupFile, ECommitted, EBackupFilesRemoved, EAddedFilesRemoved, ERemovedFilesRestored, ETempFilesRemoved}, //invalid events for ETempFile
{EBackupFile, ECommitted, EBackupFilesRemoved, EAddedFilesRemoved, ERemovedFilesRestored, ETempFilesRemoved}, //invalid events for EAddedFile
{ENone, EBackupFile, ECommitted, EBackupFilesRemoved, EAddedFilesRemoved, ERemovedFilesRestored, ETempFilesRemoved}, //invalid events for ECommitted
{ENone, ERemovedFile, EBackupFile, ETempFile, EAddedFile, EBackupFilesRemoved, EAddedFilesRemoved, ERemovedFilesRestored, ETempFilesRemoved}, //invalid events for EBackupFilesRemoved
{ENone, EBackupFile, EBackupFilesRemoved, EAddedFilesRemoved, ERemovedFilesRestored, ETempFilesRemoved}, //invalid events for EAddedFilesRemoved
//{}, //invalid events for ETempFilesRemoved
{ENone, ERemovedFile, EBackupFile, ETempFile, EAddedFile, ECommitted, EBackupFilesRemoved, ETempFilesRemoved, ERemovedFilesRestored} //invalid events for ERemovedFilesRestored
};
ASSERT(sizeof(eventsToSet)/sizeof(TIntegrityServicesEvent) == sizeof(numOfInvalidEvents)/sizeof(TInt) == sizeof(invalidEvents)/(sizeof(TIntegrityServicesEvent)*10));
for (TInt i=0; i<sizeof(eventsToSet)/sizeof(TIntegrityServicesEvent); ++i)
{
for(TInt j=0; j<numOfInvalidEvents[i]; ++j)
{
journalFile=0;
journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
journalFile->EventL(invalidEvents[i][j]); //set last event to any of the requested invalid events (also writes it to jounral file)
CleanupStack::PopAndDestroy(journalFile);
intValue.int32 = static_cast<TInt32>(eventsToSet[i]);
seekPosition=0;
OpenJournalFileL(journalFilePathInIni, defaultJournalFileMode);
SeekInJournalFileL(ESeekStart, seekPosition);
WriteIntToJournalFileL(intValue, Mode32Bit); //write the requested event to journal file (overwrites last event set by EventL())
seekToEndPosition=0;
SeekInJournalFileL(ESeekEnd, seekToEndPosition);
WriteIntToJournalFileL(extraByte, Mode8Bit);
CloseJournalFile();
//force a Sync and catch the error that should be KErrCorrupt
journalFile=0;
TRAPD(err,
journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
CleanupStack::PopAndDestroy(journalFile);
);
if(err!=KErrCorrupt)
{
ERR_PRINTF4(_L("<font color=red>CJournalFile::SynchL() returned incorrect error code. KErrCorrupt is expected and %d is returned! Conditions: last event set via EventL(): %S Event written into journal file: %S</font>"), err, eventNames[invalidEvents[i][j]], eventNames[eventsToSet[i]]);
SetTestStepResult(EFail);
}
DeleteFileL(journalFilePathInIni);
}
}
//-------------------------------------------------------------------------------------
//Steps:
// 1.) create a journal file using CJournalFile::NewLC
// 2.) add an item via AddL() or TemporaryL()
// 2.) corrupt disk information in the filename written into the file
// 3.) try to recreate journal object using CJournalFile::NewLC
// 4.) expect KErrCorrupt
//-------------------------------------------------------------------------------------
targetFileNamePtr.Set(targetFileNameBasePtr);
targetFileNamePtr.Append(_L("dummyadd_or_temp.txt"));
for(TInt i=0; i<2; i++)
{
//create a journal file and add an item via AddL() or TemporaryL()
journalFile=0;
journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
if(i==0)
{
journalFile->AddL(targetFileNamePtr);
}
else if(i==1)
{
journalFile->TemporaryL(targetFileNamePtr);
}
CleanupStack::PopAndDestroy(journalFile);
//open journal file and corrupt it by overwriting the drive letter in the file's path
seekPosition=sizeof(TInt32)+1;
OpenJournalFileL(journalFilePathInIni, defaultJournalFileMode);
SeekInJournalFileL(ESeekStart, seekPosition);
intValue = ReadIntFromJournalFileL(Mode8Bit);
intValue.int8++; //corrupt drive letter (ie: 'c' ==> 'd')
SeekInJournalFileL(ESeekStart, seekPosition);
WriteIntToJournalFileL(intValue, Mode8Bit);
CloseJournalFile();
//check that CJournalFile recognizes corruption
journalFile=0;
TRAP(err,
journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
CleanupStack::PopAndDestroy(journalFile);
);
if(err!=KErrCorrupt)
{
ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrCorrupt is expected and %d is returned!</font>"), err);
SetTestStepResult(EFail);
}
DeleteFileL(journalFilePathInIni);
}
//-------------------------------------------------------------------------------------
//Steps:
// 1.) create a journal file using CJournalFile::NewLC
// 2.) add an item via RemoveyL()
// 2.) corrupt disk information in various ways in the file
// 3.) try to recreate journal object using CJournalFile::NewL
// 4.) expect KErrCorrupt
//-------------------------------------------------------------------------------------
journalFile=0;
journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
targetFileNamePtr.Set(targetFileNameBasePtr);
targetFileNamePtr.Append(_L("dummyremove.txt"));
journalFile->RemoveL(targetFileNamePtr, targetBackupFileNamePtr);
CleanupStack::PopAndDestroy(journalFile);
OpenJournalFileL(journalFilePathInIni, defaultJournalFileMode);
seekPosition=sizeof(TInt32)+1+targetFileNamePtr.Length();
SeekInJournalFileL(ESeekStart, seekPosition);
intValue.int32 = static_cast<TInt32>(EAddedFile); //corrupt operation: originally EBackupFile is recorded here
WriteIntToJournalFileL(intValue, Mode32Bit);
//check that CJournalFile recognizes corruption
journalFile=0;
TRAP(err,
journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
CleanupStack::PopAndDestroy(journalFile);
);
if(err!=KErrCorrupt)
{
ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrCorrupt is expected and %d is returned!</font>"), err);
SetTestStepResult(EFail);
}
SeekInJournalFileL(ESeekStart, seekPosition);
intValue.int32 = static_cast<TInt32>(EBackupFile); //restore original record
WriteIntToJournalFileL(intValue, Mode32Bit);
//check that journal file is not corrupted
journalFile=0;
TRAP(err,
journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
CleanupStack::PopAndDestroy(journalFile);
);
if(err!=KErrNone)
{
ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrNone is expected and %d is returned!</font>"), err);
SetTestStepResult(EFail);
}
seekPosition=sizeof(TInt32)+1;
SeekInJournalFileL(ESeekStart, seekPosition);
intValue = ReadIntFromJournalFileL(Mode8Bit); //read first file's drive letter
intValue.int8++; //corrupt drive letter (ie: 'c' ==> 'd')
SeekInJournalFileL(ESeekStart, seekPosition);
WriteIntToJournalFileL(intValue, Mode8Bit); //write corrupt drive letter to file
//check that CJournalFile recognizes corruption
journalFile=0;
TRAP(err,
journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
CleanupStack::PopAndDestroy(journalFile);
);
if(err!=KErrCorrupt)
{
ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrCorrupt is expected and %d is returned!</font>"), err);
SetTestStepResult(EFail);
}
intValue.int8--; //restore original drive letter
SeekInJournalFileL(ESeekStart, seekPosition);
WriteIntToJournalFileL(intValue, Mode8Bit); //write original drive letter to file
//check that journal file is not corrupted
journalFile=0;
TRAP(err,
journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
CleanupStack::PopAndDestroy(journalFile);
);
if(err!=KErrNone)
{
ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrNone is expected and %d is returned!</font>"), err);
SetTestStepResult(EFail);
}
seekPosition=sizeof(TInt32)+1+targetFileNamePtr.Length()+sizeof(TInt32)+1;
SeekInJournalFileL(ESeekStart, seekPosition);
intValue = ReadIntFromJournalFileL(Mode8Bit); //read second file's drive letter (backup file name)
intValue.int8++; //corrupt drive letter (ie: 'c' ==> 'd')
SeekInJournalFileL(ESeekStart, seekPosition);
WriteIntToJournalFileL(intValue, Mode8Bit); //write corrupt drive letter to file
//check that CJournalFile recognizes corruption
journalFile=0;
TRAP(err,
journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
CleanupStack::PopAndDestroy(journalFile);
);
if(err!=KErrCorrupt)
{
ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrCorrupt is expected and %d is returned!</font>"), err);
SetTestStepResult(EFail);
}
intValue.int8--; //restore original drive letter
SeekInJournalFileL(ESeekStart, seekPosition);
WriteIntToJournalFileL(intValue, Mode8Bit); //write original drive letter to file
//check that journal file is not corrupted
journalFile=0;
TRAP(err,
journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
CleanupStack::PopAndDestroy(journalFile);
);
if(err!=KErrNone)
{
ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrNone is expected and %d is returned!</font>"), err);
SetTestStepResult(EFail);
}
CloseJournalFile();
INFO_PRINTF1(_L("Deleting journal file - Line 769"));
DeleteFileL(journalFilePathInIni);
CreateJournalFileL(journalFilePathInIni, TFileMode(TFileMode(EFileWrite) | TFileMode(EFileShareExclusive)));
journalFile=0;
TRAP(err,
journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
CleanupStack::PopAndDestroy(journalFile);
);
if(err!=KErrInUse )
{
ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrInUse is expected and %d is returned!</font>"), err);
SetTestStepResult(EFail);
}
CloseJournalFile();
INFO_PRINTF1(_L("Deleting journal file - Line 783"));
DeleteFileL(journalFilePathInIni);
CleanupStack::PopAndDestroy(2, targetFileName);
}
void CJournalFileUnitTest::ImplTestStepPostambleL()
/**
@return - void code
Override of base class virtual
*/
{
INFO_PRINTF1(_L("JournalFileUnitTest Postamble"));
delete testJournalFile;
testJournalFile=0;
iFs.Close();
iLoader.Close();
}
void CJournalFileUnitTest::OpenJournalFileL(const TDesC& aFileName, TFileMode aMode)
{
testJournalFile->OpenJournalFileL(aFileName, aMode);
}
void CJournalFileUnitTest::CreateJournalFileL(const TDesC& aFileName, TFileMode aMode)
{
testJournalFile->CreateJournalFileL(aFileName, aMode);
}
void CJournalFileUnitTest::SeekInJournalFileL(TSeek aSeekMode, TInt &aPos)
{
testJournalFile->SeekInJournalFileL(aSeekMode, aPos);
}
TIntValue CJournalFileUnitTest::ReadIntFromJournalFileL(TIntMode mode)
{
return testJournalFile->ReadIntFromJournalFileL(mode);
}
void CJournalFileUnitTest::CloseJournalFile()
{
testJournalFile->CloseJournalFile();
}
void CJournalFileUnitTest::WriteIntToJournalFileL(TIntValue value, TIntMode mode)
{
testJournalFile->WriteIntToJournalFileL(value, mode);
}
/*static*/ CTestFile* CTestFile::NewL(RFs& aFs)
{
CTestFile* self = new(ELeave) CTestFile(aFs);
return self;
}
CTestFile::CTestFile(RFs& aFs): iFs(aFs)
{
}
CTestFile::~CTestFile()
{
CloseJournalFile();
}
void CTestFile::OpenJournalFileL(const TDesC& aFileName, TFileMode aMode)
{
TInt err = journalFile.Open(iFs, aFileName, aMode);
User::LeaveIfError(err);
}
void CTestFile::CreateJournalFileL(const TDesC& aFileName, TFileMode aMode)
{
TInt err = iFs.MkDirAll(aFileName);
if(err != KErrNone && err != KErrAlreadyExists)
{
User::Leave(err);
}
err = journalFile.Create(iFs, aFileName, aMode);
User::LeaveIfError(err);
}
void CTestFile::CloseJournalFile()
{
journalFile.Close();
}
void CTestFile::WriteIntToJournalFileL(TIntValue value, TIntMode mode)
{
HBufC8* fileIOBuffer = HBufC8::NewLC(10);
TPtr8 fileIOBufferPtr(fileIOBuffer->Des());
TPckgC<TInt32> pckg(value.int32);
switch(mode)
{
case Mode8Bit:
case Mode16Bit:
case Mode32Bit:
fileIOBufferPtr.Append(pckg);
User::LeaveIfError(journalFile.Write(fileIOBufferPtr, static_cast<TInt>(mode)));
break;
default:
User::Leave(KErrArgument);
break;
}
CleanupStack::PopAndDestroy(fileIOBuffer);
}
TIntValue CTestFile::ReadIntFromJournalFileL(TIntMode mode)
{
HBufC8* fileIOBuffer = HBufC8::NewLC(10);
TPtr8 fileIOBufferPtr(fileIOBuffer->Des());
User::LeaveIfError(journalFile.Read(fileIOBufferPtr, static_cast<TInt>(mode)));
TIntValue ret = {0};
switch(mode)
{
case Mode8Bit:
case Mode16Bit:
case Mode32Bit:
{
for(TInt i=0; i<static_cast<TInt>(mode); ++i)
{
ret.int32 |= TInt32((*fileIOBuffer)[i]) << (8*i);
}
break;
}
default:
User::Leave(KErrArgument);
break;
}
CleanupStack::PopAndDestroy(fileIOBuffer);
return ret;
}
void CTestFile::SeekInJournalFileL(TSeek aSeekMode, TInt &aPos)
{
User::LeaveIfError(journalFile.Seek(aSeekMode, aPos));
}
//------------------------------------------------------------------------------------------------------------
CJournalFileUnitTestScenarioBase::CJournalFileUnitTestScenarioBase(CStsTestServer &aStsTestServer): CStsBaseTestStep(aStsTestServer), iCleanupNeeded(ETrue)
{
}
CJournalFileUnitTestScenarioBase::~CJournalFileUnitTestScenarioBase()
{
iFs.Close();
iLoader.Close();
delete iTargetFileName;
delete iBackupFileName;
}
void CJournalFileUnitTestScenarioBase::ImplTestStepPreambleL()
{
INFO_PRINTF1(_L("CJournalFileUnitTestScenarioBase Preamble"));
iJournalFileName.Set(GetTargetFilePathFromConfigL());
User::LeaveIfError(iFs.Connect());
User::LeaveIfError(iLoader.Connect());
iTargetFileName = HBufC::NewL(KMaxFileName);
iBackupFileName = HBufC::NewL(KMaxFileName);
TParsePtrC journalFilePathParse(iJournalFileName);
TPtr ptr(iTargetFileName->Des());
ptr.Append(journalFilePathParse.DriveAndPath());
ptr.Append(_L("journalfile_oom_test_dummyfile.txt"));
iJournaldrive = journalFilePathParse.Drive();
SetTestStepResult(EPass);
}
void CJournalFileUnitTestScenarioBase::ImplTestStepL()
{
CleanupStack::PushL(TCleanupItem(&CJournalFileUnitTestScenarioBase::InTestCleanup, this));
ImplTestCaseScenarioL();
CleanupStack::PopAndDestroy(this);
}
void CJournalFileUnitTestScenarioBase::ImplTestStepPostambleL()
{
INFO_PRINTF1(_L("CJournalFileUnitTestScenarioBase Postamble"));
delete iTargetFileName;
iTargetFileName=0;
delete iBackupFileName;
iBackupFileName=0;
iFs.Close();
iLoader.Close();
TRAP_IGNORE(DeleteFileL(iJournalFileName));
}
/*static*/void CJournalFileUnitTestScenarioBase::InTestCleanup(TAny* aObject)
{
CJournalFileUnitTestScenarioBase* object=static_cast<CJournalFileUnitTestScenarioBase*>(aObject);
object->INFO_PRINTF1(_L("CJournalFileUnitTestScenarioBase::InTestCleanup()"));
if(object->iCleanupNeeded)
{
TRAP_IGNORE(object->DeleteFileL(object->iJournalFileName));
}
}
//------------------------------------------------------------------------------------------------------------
CJournalFileUnitTestAdd::CJournalFileUnitTestAdd(CStsTestServer &aStsTestServer): CJournalFileUnitTestScenarioBase(aStsTestServer)
{
SetTestStepName(KJournalFileUnitTestAdd);
}
void CJournalFileUnitTestAdd::ImplTestCaseScenarioL()
{
INFO_PRINTF1(_L("CJournalFileUnitTestAdd in test step"));
CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, iJournalFileName, iJournaldrive);
journalFile->AddL(*iTargetFileName);
CleanupStack::PopAndDestroy(journalFile);
}
//------------------------------------------------------------------------------------------------------------
CJournalFileUnitTestTemp::CJournalFileUnitTestTemp(CStsTestServer &aStsTestServer): CJournalFileUnitTestScenarioBase(aStsTestServer)
{
SetTestStepName(KJournalFileUnitTestTemp);
}
void CJournalFileUnitTestTemp::ImplTestCaseScenarioL()
{
INFO_PRINTF1(_L("CJournalFileUnitTestTemp in test step"));
CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, iJournalFileName, iJournaldrive);
journalFile->TemporaryL(*iTargetFileName);
CleanupStack::PopAndDestroy(journalFile);
}
//------------------------------------------------------------------------------------------------------------
CJournalFileUnitTestRemove::CJournalFileUnitTestRemove(CStsTestServer &aStsTestServer): CJournalFileUnitTestScenarioBase(aStsTestServer)
{
SetTestStepName(KJournalFileUnitTestRemove);
}
void CJournalFileUnitTestRemove::ImplTestCaseScenarioL()
{
INFO_PRINTF1(_L("CJournalFileUnitTestRemove in test step"));
TPtr backupFileNamePtr(iBackupFileName->Des());
CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, iJournalFileName, iJournaldrive);
journalFile->RemoveL(*iTargetFileName, backupFileNamePtr);
CleanupStack::PopAndDestroy(journalFile);
}
//------------------------------------------------------------------------------------------------------------
CJournalFileUnitTestRead::CJournalFileUnitTestRead(CStsTestServer &aStsTestServer): CJournalFileUnitTestScenarioBase(aStsTestServer)
{
iCleanupNeeded=EFalse;
SetTestStepName(KJournalFileUnitTestRead);
}
void CJournalFileUnitTestRead::ImplTestCaseScenarioL()
{
INFO_PRINTF1(_L("CJournalFileUnitTestRead in test step"));
CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, iJournalFileName, iJournaldrive);
CleanupStack::PopAndDestroy(journalFile);
}
//------------------------------------------------------------------------------------------------------------
CJournalFileUnitTestEvent::CJournalFileUnitTestEvent(CStsTestServer &aStsTestServer): CJournalFileUnitTestScenarioBase(aStsTestServer)
{
}
void CJournalFileUnitTestEvent::ImplTestCaseScenarioL()
{
INFO_PRINTF1(_L("CJournalFileUnitTestEvent in test step"));
CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, iJournalFileName, iJournaldrive);
journalFile->EventL(ECommitted);
CleanupStack::PopAndDestroy(journalFile);
}
//------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------
CJournalUnitTest::CJournalUnitTest(CStsTestServer &aStsTestServer): CStsBaseTestStep(aStsTestServer)
{
// Call base class method to set up the human readable name for logging
SetTestStepName(KJournalUnitTest);
}
CJournalUnitTest::~CJournalUnitTest()
{
delete iTestFileInterface;
iFs.Close();
iLoader.Close();
}
void CJournalUnitTest::ImplTestStepPreambleL()
{
INFO_PRINTF1(_L("JournalFileUnitTest Preamble"));
iJournalPathInIni.Set(GetTargetFilePathFromConfigL());
iTrID = GetTransactionIdFromConfigL();
User::LeaveIfError(iFs.Connect());
User::LeaveIfError(iLoader.Connect());
iTestFileInterface = CTestFile::NewL(iFs);
SetTestStepResult(EPass);
}
void CJournalUnitTest::ImplTestStepL()
{
INFO_PRINTF1(_L("JournalUnitTest in test step"));
SetTestStepResult(EPass);
TestCase1L();
}
void CJournalUnitTest::ImplTestStepPostambleL()
{
INFO_PRINTF1(_L("JournalFileUnitTest Postamble"));
delete iTestFileInterface;
iTestFileInterface=0;
iFs.Close();
iLoader.Close();
}
void CJournalUnitTest::TestCase1L()
{
INFO_PRINTF1(_L("JournalFileUnitTest Test Case1"));
//-------------------------------------------------------------------------------------
//Steps:
// 1.) create a corrupt journal file on C drive (by writing invalid event into the file /eg: with a value of EAddedFile+1000/)
// 2.) Create a journal
// 3.) Add a file to the journal on C drive by invoking CJounral::AddL()
// 4.) this will create a new journal file object representing journal activity on drive C, however due to the corrupt file being already on the C drive CJournalFile::NewLC will throw KErrCorrupt
// 5.) expect KErrCorrupt
// note: the purpose of this testcase to excersise the conditional branches in CJournal::PrepareToWriteL
//-------------------------------------------------------------------------------------
TInt err=0;
TDriveUnit driveUnitC(KDriveLetterC);
TDriveUnit driveUnitE(KDriveLetterE);
HBufC* journalFileName = HBufC::NewLC(KMaxFileName);
HBufC* targetFileName = HBufC::NewLC(KMaxFileName);
TPtr journalFileNamePtr(journalFileName->Des());
journalFileNamePtr.Append(driveUnitC.Name());
CJournal::CreateJournalFileNameL(iTrID, iJournalPathInIni, journalFileNamePtr);
//create file path base (eg: drive:\path\)
TPtr targetFileNameBasePtr(targetFileName->Des());
targetFileNameBasePtr.Append(driveUnitC.Name());
targetFileNameBasePtr.Append(iJournalPathInIni);
//open up the file via the test file interface (for writing corrupt data)
iTestFileInterface->CreateJournalFileL(journalFileNamePtr, defaultJournalFileMode);
TInt seekPosition=0;
TIntValue intValue = {0};
intValue.int32=static_cast<TInt32>(EAddedFile)+1000; //corrupt data in file (eg: write operation value to an invalid value)
//corrupt data in journal file
iTestFileInterface->SeekInJournalFileL(ESeekStart, seekPosition);
iTestFileInterface->WriteIntToJournalFileL(intValue, Mode32Bit);
iTestFileInterface->CloseJournalFile();
TPtr targetFileNamePtr(targetFileNameBasePtr);
targetFileNamePtr.Append(_L("dummyadd.txt"));
//create a journal and add a file on C drive: that will force CJournalFile to read in and process the
//previously created corrupt file. As the file contains corrupt information CJournalFile construction is expected to fail with KErrCorrupt
CJournal* journal = CJournal::NewLC(iFs, iLoader, iTrID, iJournalPathInIni);
TRAP(err, journal->AddL(targetFileNamePtr));
if(err!=KErrCorrupt)
{
ERR_PRINTF2(_L("<font color=red>CJournal::AddL() returned incorrect error code. KErrCorrupt is expected and %d is returned!</font>"), err);
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(journal); journal=0;
//clean up: delete created journal file and drive file (.drv)
DeleteFileL(*journalFileName);
//reuse targetFileName buffer to create .drv filename to delete that file
*targetFileName=KEmptyString;
targetFileNamePtr.Set(targetFileName->Des());
CJournal::CreateDrvFileNameL(iTrID, iJournalPathInIni, targetFileNamePtr);
TRAP_IGNORE(DeleteFileL(targetFileNamePtr)); //clean up .drv file in case it's been created but avoid causing leave in case it hasn't
CleanupStack::PopAndDestroy(targetFileName);
CleanupStack::PopAndDestroy(journalFileName);
}
//------------------------------------------------------------------------------------------------------------
CJournalUnitTestScenarioBase::CJournalUnitTestScenarioBase(CStsTestServer &aStsTestServer): CStsBaseTestStep(aStsTestServer)
{
iDriveUnitC = _L("c");
iDriveUnitE = _L("e");
}
CJournalUnitTestScenarioBase::~CJournalUnitTestScenarioBase()
{
iFs.Close();
iLoader.Close();
delete iTargetFileName;
delete iJournalFileName;
delete iDrvFileName;
delete iBackupFileName;
}
void CJournalUnitTestScenarioBase::ImplTestStepPreambleL()
{
INFO_PRINTF1(_L("CJournalUnitTestScenarioBase::ImplTestStepPreambleL()"));
iJournalPathInIni.Set(GetTargetFilePathFromConfigL());
iTrID = GetTransactionIdFromConfigL();
User::LeaveIfError(iFs.Connect());
User::LeaveIfError(iLoader.Connect());
iTargetFileName = HBufC::NewL(KMaxFileName);
iJournalFileName = HBufC::NewL(KMaxFileName);
iDrvFileName = HBufC::NewL(KMaxFileName);
iBackupFileName = HBufC::NewL(KMaxFileName);
TPtr ptr(iJournalFileName->Des());
ptr.Append(iDriveUnitC.Name());
ptr.Append(iJournalPathInIni);
ptr.AppendNumUC(iTrID, EHex);
ptr.Append(KKournalFileExt);
ptr.Set(iTargetFileName->Des());
ptr.Append(iDriveUnitC.Name());
ptr.Append(iJournalPathInIni);
ptr.Set(iDrvFileName->Des());
CJournal::CreateDrvFileNameL(iTrID, iJournalPathInIni, ptr);
SetTestStepResult(EPass);
}
void CJournalUnitTestScenarioBase::ImplTestStepL()
{
INFO_PRINTF1(_L("CJournalUnitTestScenarioBase::ImplTestStepL()"));
TPtr basePathPtr(iTargetFileName->Des());
TPtr fileNamePtr(basePathPtr);
TCleanupItem inTestCleanupItem(&CJournalUnitTestScenarioBase::InTestCleanUp, this);
CleanupStack::PushL(inTestCleanupItem);
CJournal* journal = CJournal::NewLC(iFs, iLoader, iTrID, iJournalPathInIni);
*iBackupFileName=KEmptyString;
TPtr backupFileNamePtr(iBackupFileName->Des());
fileNamePtr.Set(basePathPtr);
fileNamePtr.Append(_L("journal_oom_test_dummyremovefile.txt"));
basePathPtr.Replace(0, 2, iDriveUnitC.Name());
journal->RemoveL(fileNamePtr, backupFileNamePtr);
*iBackupFileName=KEmptyString;
backupFileNamePtr.Set(iBackupFileName->Des());
basePathPtr.Replace(0, 2, iDriveUnitE.Name());
journal->RemoveL(fileNamePtr, backupFileNamePtr);
fileNamePtr.Set(basePathPtr);
fileNamePtr.Append(_L("journal_oom_test_dummytempfile.txt"));
basePathPtr.Replace(0, 2, iDriveUnitC.Name());
journal->TemporaryL(fileNamePtr);
basePathPtr.Replace(0, 2, iDriveUnitE.Name());
journal->TemporaryL(fileNamePtr);
fileNamePtr.Set(basePathPtr);
fileNamePtr.Append(_L("journal_oom_test_dummyaddfile.txt"));
basePathPtr.Replace(0, 2, iDriveUnitC.Name());
journal->AddL(fileNamePtr);
basePathPtr.Replace(0, 2, iDriveUnitE.Name());
journal->AddL(fileNamePtr);
ScenarioEndL(journal);
CleanupStack::PopAndDestroy(journal);
CleanupStack::PopAndDestroy(this);
}
void CJournalUnitTestScenarioBase::ImplTestStepPostambleL()
{
INFO_PRINTF1(_L("CJournalUnitTestScenarioBase::ImplTestStepPostambleL()"));
delete iTargetFileName;
iTargetFileName=0;
delete iJournalFileName;
iJournalFileName=0;
delete iDrvFileName;
iDrvFileName=0;
delete iBackupFileName;
iBackupFileName=0;
iFs.Close();
iLoader.Close();
}
/*static*/ void CJournalUnitTestScenarioBase::InTestCleanUp(TAny* aObject)
{
CJournalUnitTestScenarioBase* object=static_cast<CJournalUnitTestScenarioBase*>(aObject);
object->INFO_PRINTF1(_L("CJournalUnitTestScenarioBase::InTestCleanUp()"));
TPtr ptr(object->iJournalFileName->Des());
ptr.Replace(0, 2, object->iDriveUnitC.Name());
TRAP_IGNORE(object->DeleteFileL(ptr)); //delete journal file on C drive
ptr.Replace(0, 2, object->iDriveUnitE.Name());
TRAP_IGNORE(object->DeleteFileL(ptr)); //delete journal file on E drive
TRAP_IGNORE(object->DeleteFileL(*(object->iDrvFileName))); //delete drv file on system drive
}
//------------------------------------------------------------------------------------------------------------
CJournalUnitTestInstall::CJournalUnitTestInstall(CStsTestServer &aStsTestServer): CJournalUnitTestScenarioBase(aStsTestServer)
{
// Call base class method to set up the human readable name for logging
SetTestStepName(KJournalUnitTestInstall);
}
void CJournalUnitTestInstall::ScenarioEndL(CJournal* aJournal)
{
aJournal->CommitL();
}
//------------------------------------------------------------------------------------------------------------
CJournalUnitTestRollback::CJournalUnitTestRollback(CStsTestServer &aStsTestServer): CJournalUnitTestScenarioBase(aStsTestServer)
{
// Call base class method to set up the human readable name for logging
SetTestStepName(KJournalUnitTestRollback);
}
void CJournalUnitTestRollback::ScenarioEndL(CJournal* aJournal)
{
aJournal->RollBackL();
}
//------------------------------------------------------------------------------------------------------------
CIntegrityServicesTestScenarioBase::CIntegrityServicesTestScenarioBase(CStsTestServer &aStsTestServer): CStsBaseTestStep(aStsTestServer)
{
iDriveUnitC = _L("c");
iDriveUnitE = _L("e");
}
CIntegrityServicesTestScenarioBase::~CIntegrityServicesTestScenarioBase()
{
iFs.Close();
iLoader.Close();
delete iTargetFileName;
delete iJournalFileName;
delete iDrvFileName;
delete iBackupFileName;
delete iTransactionBackupDirectoryPath;
}
void CIntegrityServicesTestScenarioBase::ImplTestStepPreambleL()
{
INFO_PRINTF1(_L("IntegrityServicesTestOOM Preamble"));
iTargetPathInIni.Set(GetTargetFilePathFromConfigL());
iTrID = GetTransactionIdFromConfigL();
User::LeaveIfError(iFs.Connect());
User::LeaveIfError(iLoader.Connect());
iTargetFileName = HBufC::NewL(KMaxFileName);
iJournalFileName = HBufC::NewL(KMaxFileName);
iDrvFileName = HBufC::NewL(KMaxFileName);
iBackupFileName = HBufC::NewL(KMaxFileName);
iTransactionBackupDirectoryPath = HBufC::NewL(KMaxFileName);
TPtr ptr(iJournalFileName->Des());
ptr.Append(iDriveUnitC.Name());
CJournal::CreateJournalFileNameL(iTrID, KTransactionPath, ptr);
ptr.Set(iDrvFileName->Des());
CJournal::CreateDrvFileNameL(iTrID, KTransactionPath, ptr);
TParsePtrC parse(*iDrvFileName);
ptr.Set(iTransactionBackupDirectoryPath->Des()); //this is the directory that holds the backup files for the transaction
ptr.Append(parse.DriveAndPath());
ptr.Append(parse.Name());
ptr.Set(iTargetFileName->Des());
ptr.Append(iDriveUnitC.Name());
ptr.Append(iTargetPathInIni);
NormalizeDirectoryName(ptr); //removes trailing slash
SetTestStepResult(EPass);
}
void CIntegrityServicesTestScenarioBase::ImplTestStepL()
{
TPtr basePathPtr(iTargetFileName->Des());
TPtr fileNamePtr(basePathPtr);
RFile newFile;
TUint fileMode(EFileShareExclusive | EFileWrite);
TCleanupItem inTestCleanupItem(&CIntegrityServicesTestScenarioBase::InTestCleanUp, this);
CleanupStack::PushL(inTestCleanupItem);
CIntegrityServices* integrityServices = CIntegrityServices::NewLC(iTrID);
fileNamePtr.Set(basePathPtr);
fileNamePtr.Append(_L("\\integrityservices_oom_test_dummyremovefile.txt"));
basePathPtr.Replace(0, 2, iDriveUnitC.Name());
integrityServices->RemoveL(fileNamePtr);
basePathPtr.Replace(0, 2, iDriveUnitE.Name());
integrityServices->RemoveL(fileNamePtr);
fileNamePtr.Set(basePathPtr);
fileNamePtr.Append(_L("\\integrityservices_oom_test_dummyregistertempfile.txt"));
basePathPtr.Replace(0, 2, iDriveUnitC.Name());
integrityServices->RegisterTemporaryL(fileNamePtr);
basePathPtr.Replace(0, 2, iDriveUnitE.Name());
integrityServices->RegisterTemporaryL(fileNamePtr);
fileNamePtr.Set(basePathPtr);
fileNamePtr.Append(_L("\\integrityservices_oom_test_dummycreatetempfile.txt"));
basePathPtr.Replace(0, 2, iDriveUnitC.Name());
CleanupClosePushL(newFile);
integrityServices->CreateTemporaryL(fileNamePtr, newFile, fileMode);
CleanupStack::PopAndDestroy(&newFile);
basePathPtr.Replace(0, 2, iDriveUnitE.Name());
CleanupClosePushL(newFile);
integrityServices->CreateTemporaryL(fileNamePtr, newFile, fileMode);
CleanupStack::PopAndDestroy(&newFile);
fileNamePtr.Set(basePathPtr);
fileNamePtr.Append(_L("\\integrityservices_oom_test_dummyaddfile.txt"));
basePathPtr.Replace(0, 2, iDriveUnitC.Name());
integrityServices->RegisterNewL(fileNamePtr);
basePathPtr.Replace(0, 2, iDriveUnitE.Name());
integrityServices->RegisterNewL(fileNamePtr);
fileNamePtr.Set(basePathPtr);
fileNamePtr.Append(_L("\\integrityservices_oom_test_dummycreatenewfile.txt"));
basePathPtr.Replace(0, 2, iDriveUnitC.Name());
CleanupClosePushL(newFile);
integrityServices->CreateNewL(fileNamePtr, newFile, fileMode);
CleanupStack::PopAndDestroy(&newFile);
basePathPtr.Replace(0, 2, iDriveUnitE.Name());
CleanupClosePushL(newFile);
integrityServices->CreateNewL(fileNamePtr, newFile, fileMode);
CleanupStack::PopAndDestroy(&newFile);
fileNamePtr.Set(basePathPtr);
fileNamePtr.Append(_L("\\integrityservices_oom_test_dummyoverwritefile.txt"));
basePathPtr.Replace(0, 2, iDriveUnitC.Name());
CleanupClosePushL(newFile);
integrityServices->OverwriteL(fileNamePtr, newFile, fileMode);
CleanupStack::PopAndDestroy(&newFile);
basePathPtr.Replace(0, 2, iDriveUnitE.Name());
CleanupClosePushL(newFile);
integrityServices->OverwriteL(fileNamePtr, newFile, fileMode);
CleanupStack::PopAndDestroy(&newFile);
ScenarioEndL(integrityServices);
CleanupStack::PopAndDestroy(integrityServices);
CleanupStack::PopAndDestroy(this);
}
void CIntegrityServicesTestScenarioBase::ImplTestStepPostambleL()
{
INFO_PRINTF1(_L("IntegrityServicesTestOOM Postamble"));
delete iTargetFileName;
iTargetFileName=0;
delete iJournalFileName;
iJournalFileName=0;
delete iDrvFileName;
iDrvFileName=0;
delete iBackupFileName;
iBackupFileName=0;
delete iTransactionBackupDirectoryPath;
iTransactionBackupDirectoryPath=0;
iFs.Close();
iLoader.Close();
}
/*static*/void CIntegrityServicesTestScenarioBase::InTestCleanUp(TAny* aObject)
{
CIntegrityServicesTestScenarioBase* object=static_cast<CIntegrityServicesTestScenarioBase*>(aObject);
//first clean up transaction related files
TPtr ptr(object->iJournalFileName->Des());
ptr.Replace(0, 2, object->iDriveUnitC.Name());
TRAP_IGNORE(object->DeleteFileL(ptr)); //delete journal file on C drive
ptr.Replace(0, 2, object->iDriveUnitE.Name());
TRAP_IGNORE(object->DeleteFileL(ptr)); //delete journal file on E drive
TRAP_IGNORE(object->DeleteFileL(*(object->iDrvFileName))); //delete drv file on system drive
ptr.Set(object->iTransactionBackupDirectoryPath->Des());
ptr.Replace(0, 2, object->iDriveUnitC.Name());
TRAP_IGNORE(object->DeleteFileL(ptr)); //delete backup directory on C drive
ptr.Replace(0, 2, object->iDriveUnitE.Name());
TRAP_IGNORE(object->DeleteFileL(ptr)); //delete backup directory on E drive
//then clean up all the added/created/etc... files
ptr.Set(object->iTargetFileName->Des());
ptr.Replace(0, 2, object->iDriveUnitC.Name());
TRAP_IGNORE(object->DeleteFileL(ptr)); //delete target dir on C drive
ptr.Replace(0, 2, object->iDriveUnitE.Name());
TRAP_IGNORE(object->DeleteFileL(ptr)); //delete target dir on E drive
}
void CIntegrityServicesTestScenarioBase::NormalizeDirectoryName(TDes& aFileName)
{
TInt lastCharPos = aFileName.Length() - 1;
if ( lastCharPos >= 0 && aFileName[lastCharPos] == KPathDelimiter &&
aFileName.Locate(KPathDelimiter) != lastCharPos) // Take care not to remove slash from "c:\" and the like
{
aFileName.Delete(lastCharPos, 1);
}
}
//------------------------------------------------------------------------------------------------------------
CIntegrityServicesTestInstall::CIntegrityServicesTestInstall(CStsTestServer &aStsTestServer): CIntegrityServicesTestScenarioBase(aStsTestServer)
{
// Call base class method to set up the human readable name for logging
SetTestStepName(KIntegrityservicesUnitTestInstall);
}
void CIntegrityServicesTestInstall::ScenarioEndL(Usif::CIntegrityServices* aIntegrServ)
{
aIntegrServ->CommitL();
}
//------------------------------------------------------------------------------------------------------------
CIntegrityServicesTestRollback::CIntegrityServicesTestRollback(CStsTestServer &aStsTestServer): CIntegrityServicesTestScenarioBase(aStsTestServer)
{
// Call base class method to set up the human readable name for logging
SetTestStepName(KIntegrityservicesUnitTestRollback);
}
void CIntegrityServicesTestRollback::ScenarioEndL(Usif::CIntegrityServices* aIntegrServ)
{
aIntegrServ->RollBackL();
}