// Copyright (c) 1998-2010 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//
#include <s32file.h>
#include <e32test.h>
#include <e32math.h>
const TInt KTestCleanupStack=0x20;
// This is a path specification and should not be used as is
_LIT(KFileLocationSpec, "Z:\\STOR-TST\\T_COMPACT.DAT");
_LIT(KResultsFile,"RESULTS_%d.TXT");
static TFileName TheResultsFile;
static TBool AllTests=ETrue;
static TInt Iterations=10000;
static TInt DataVolume=160;
static TInt CompactFrequency=40;
class RLog
{
public:
void CreateL(RFs& aFs, const TDesC& aFile);
void Close();
void PrintL(const char* aFormat, ...);
private:
RFileWriteStream iLog;
};
LOCAL_D CTrapCleanup* TheTrapCleanup;
LOCAL_D RTest test(_L("t_storfcomp"));
LOCAL_D RFs TheFs;
LOCAL_D RLog TheLog;
class StopWatch
{
public:
void Start();
TUint Stop();
private:
TTime iTime;
};
void StopWatch::Start()
{
iTime.UniversalTime();
}
TUint StopWatch::Stop()
{
TTime t;
t.UniversalTime();
TInt64 i = ((t.MicroSecondsFrom(iTime).Int64()) + 500)/1000;
return I64LOW(i);
}
StopWatch CompactSW;
void CompactL(CFileStore& aStore)
//
// Compact the file and record the stats
//
{
aStore.CommitL();
TInt startSize;
User::LeaveIfError(aStore.File().Size(startSize));
CompactSW.Start();
TInt wasted = aStore.CompactL();
aStore.CommitL();
TUint ms = CompactSW.Stop();
TInt endSize;
User::LeaveIfError(aStore.File().Size(endSize));
TheLog.PrintL("%d\t%d\t%d\t%u\n",startSize, endSize, wasted, ms);
}
void ReclaimCompactL(CFileStore& aStore, TInt aTrigger)
//
// Reclaim the file and compact on trigger
//
{
TInt startSize;
User::LeaveIfError(aStore.File().Size(startSize));
CompactSW.Start();
TBool compacted = EFalse;
if (aTrigger == 0 || aStore.ReclaimL() * 100 > startSize * aTrigger)
{
aStore.CompactL();
aStore.CommitL();
compacted = ETrue;
}
TUint ms = CompactSW.Stop();
TInt endSize;
User::LeaveIfError(aStore.File().Size(endSize));
TheLog.PrintL("%s\t%d\t%u\n",compacted ? "Compact" : "Reclaim", startSize - endSize, ms);
}
void WriteBytesL(RWriteStream& s, TInt aCount)
{
const TInt KBufSize = 512;
TUint8 buf[KBufSize];
while (aCount > KBufSize)
{
s.WriteL(buf, KBufSize);
aCount -= KBufSize;
}
s.WriteL(buf, aCount);
s.CommitL();
}
TStreamId CreateStreamL(CStreamStore& aStore, TInt aSize)
{
RStoreWriteStream s;
TStreamId id = s.CreateLC(aStore);
WriteBytesL(s, aSize);
CleanupStack::PopAndDestroy(&s);
return id;
}
TInt Random(TUint aLimit)
{
return Math::Random() % aLimit;
}
TBool AllocationFailure()
{
User::__DbgSetAllocFail(RHeap::EUser,RHeap::EFailNext,1);
TAny* cell = User::Alloc(4);
User::Free(cell);
User::__DbgSetAllocFail(RHeap::EUser,RHeap::ENone,1);
return cell == 0;
}
/**
@SYMTestCaseID SYSLIB-STORE-CT-1144
@SYMTestCaseDesc Tests for CFileStore::CompactL() function
@SYMTestPriority High
@SYMTestActions Attempt for compaction process on the store.Tests for KErrNone flag
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ0000
*/
void BasicCompactionTestsL()
{
const TInt KTestCount = 40;
const TInt KTestSize = 50;
TParsePtrC parse(KFileLocationSpec);
//
test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1144 "));
CFileStore* store = CPermanentFileStore::ReplaceLC(TheFs, parse.NameAndExt(), EFileRead|EFileWrite);
store->SetTypeL(store->Layout());
//
TheLog.PrintL("Compact uncommitted empty store\n");
TRAPD(r, store->CompactL());
test (r == KErrNone);
//
TheLog.PrintL("Compact committed empty store\n");
r = store->Commit();
test (r == KErrNone);
TRAP(r, store->CompactL());
test (r == KErrNone);
//
TheLog.PrintL("Compact empty store with full TOC\n");
TStreamId streams[KTestCount];
TInt i;
for (i = 0; i < KTestCount; ++i)
streams[i] = CreateStreamL(*store, KTestSize);
store->CommitL();
for (i = 0; i < KTestCount; ++i)
store->DeleteL(streams[i]);
store->CommitL();
TRAP(r, store->CompactL());
test (r == KErrNone);
//
TheLog.PrintL("Compact empty store with delta TOC\n");
streams[0] = CreateStreamL(*store, KTestSize);
store->CommitL();
store->DeleteL(streams[0]);
store->CommitL();
TRAP(r, store->CompactL());
test (r == KErrNone);
//
CleanupStack::PopAndDestroy(store);
}
/**
@SYMTestCaseID SYSLIB-STORE-CT-1145
@SYMTestCaseDesc Testing fallback compaction algorithm
@SYMTestPriority High
@SYMTestActions Tests for compaction process on the store,
If we have allocation failure we can test that the fallback algorithm is in place
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ0000
*/
void CompactionAlgorithmTestL()
{
const TInt KTestCount = 200;
const TInt KTestSize = 50;
const TInt KBeyondSuccess = 2;
TInt stopat = KMaxTInt;
TInt bestTime = -1;
TParsePtrC parse(KFileLocationSpec);
//
test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1145 "));
TheLog.PrintL("Testing fallback compaction algorithm\n");
//
for (TInt failat = 1; failat <= stopat; ++failat)
{
TheLog.PrintL("Fail allocation #%d: ", failat);
//
// prepare the store. Leave a single hole at the beginning
CFileStore* store = CPermanentFileStore::ReplaceLC(TheFs, parse.NameAndExt(), EFileRead|EFileWrite);
store->SetTypeL(store->Layout());
TStreamId first = CreateStreamL(*store, KTestSize);
for (TInt i = 1; i < KTestCount; ++i)
CreateStreamL(*store, KTestSize);
store->CommitL();
store->DeleteL(first);
store->CommitL();
//
User::__DbgSetAllocFail(RHeap::EUser,RHeap::EFailNext,failat);
CompactSW.Start();
TRAPD(r, store->CompactL(); store->CommitL();)
TInt ms = CompactSW.Stop();
User::__DbgSetAllocFail(RHeap::EUser,RHeap::ENone,1);
//
if (r != KErrNone)
{
test (bestTime == -1);
TheLog.PrintL("compaction failed\n");
}
else
{
TheLog.PrintL("compaction succeeded in %u ms\n", ms);
if (bestTime == -1)
{
bestTime = ms;
stopat = failat + KBeyondSuccess; //stop after a few passes after sucsss
}
else if (ms < bestTime)
{
if (ms < bestTime/2)
stopat = failat + KBeyondSuccess; // new algorithm has kicked in
bestTime = ms;
}
}
CleanupStack::PopAndDestroy(store);
}
}
struct TTracker
{
TStreamId iId;
TInt iSize;
};
CFileStore* InitialiseStoreLC(RArray<TTracker>& aStreams, TInt aDataVolume, TInt aAverageSize)
{
TParsePtrC parse(KFileLocationSpec);
CFileStore* store = CPermanentFileStore::ReplaceLC(TheFs, parse.NameAndExt(), EFileRead|EFileWrite);
store->SetTypeL(store->Layout());
for (TInt count = Max(1,(aDataVolume + aAverageSize/2)/aAverageSize); count > 0; --count)
{
TInt size;
if (count == 1)
size = aDataVolume;
else
{
size = aDataVolume / count;
TInt spread = Min(aAverageSize, size);
size += Random(spread) - spread/2;
}
TTracker e;
e.iSize = size;
e.iId = CreateStreamL(*store, size);
User::LeaveIfError(aStreams.Append(e));
aDataVolume -= size;
}
store->CommitL();
return store;
}
/**
@SYMTestCaseID SYSLIB-STORE-CT-1146
@SYMTestCaseDesc Tests for compaction on store
@SYMTestPriority High
@SYMTestActions Tests for CFileStore::CompactL() function
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ0000
*/
void CompactionTestL(const TInt aIterations, const TInt aDataVolume, const TInt aAverageSize, const TInt aCommitFrequency, const TInt aCompactionFrequency)
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1146 "));
TheLog.PrintL("CompactionTest : \n");
TheLog.PrintL("\tIterations:\t%d\n",aIterations);
TheLog.PrintL("\tDataVolume:\t%d\n",aDataVolume);
TheLog.PrintL("\tAverageSize:\t%d\n",aAverageSize);
TheLog.PrintL("\tCommitFrequency:\t%d\n",aCommitFrequency);
TheLog.PrintL("\tCompactionFrequency:\t%d\n\n",aCompactionFrequency);
RArray<TTracker> streams(8);
CleanupClosePushL(streams);
CFileStore* store = InitialiseStoreLC(streams, aDataVolume, aAverageSize);
const TInt maxCount = streams.Count() + (streams.Count() / 5);
TInt size = aDataVolume;
const TInt span = aDataVolume / 10; // +- 10%
for (TInt i = aIterations ; --i >= 0; )
{
TInt from = Random(streams.Count());
TInt to = Random(maxCount);
TInt tfr = to == from ? 0 : Random(streams[from].iSize + 1);
TInt adj = Random(span - 1) - span/2;
if (size > aDataVolume + span/2)
adj -= size - (aDataVolume + span/2);
else if (size < aDataVolume - span/2)
adj += (aDataVolume - span/2) - size;
if (adj < 0)
{
if (adj < tfr - streams[from].iSize)
adj = tfr - streams[from].iSize;
}
TInt fromSize = streams[from].iSize - tfr;
if (adj < 0 || to == from)
fromSize += adj;
if (fromSize > 0)
{
RStoreWriteStream s;
s.ReplaceLC(*store, streams[from].iId);
WriteBytesL(s, fromSize);
CleanupStack::PopAndDestroy(&s);
streams[from].iSize = fromSize;
}
if (to != from)
{
if (to < streams.Count())
{
TInt toSize = streams[to].iSize + tfr;
if (adj > 0)
toSize += adj;
RStoreWriteStream s;
s.ReplaceLC(*store, streams[to].iId);
WriteBytesL(s, toSize);
CleanupStack::PopAndDestroy(&s);
streams[to].iSize = toSize;
}
else
{
TInt toSize = tfr;
if (adj > 0)
toSize += adj;
TTracker e;
e.iSize = toSize;
e.iId = CreateStreamL(*store, toSize);
User::LeaveIfError(streams.Append(e));
}
}
if (fromSize <= 0)
{
store->DeleteL(streams[from].iId);
streams.Remove(from);
}
size += adj;
//
if (Random(aCommitFrequency) == 0)
{
store->CommitL();
if (aCompactionFrequency <= 0)
ReclaimCompactL(*store, -aCompactionFrequency);
}
if (aCompactionFrequency > 0 && Random(aCompactionFrequency) == 0)
CompactL(*store);
}
CleanupStack::PopAndDestroy(store);
CleanupStack::PopAndDestroy(&streams);
TheLog.PrintL("\nCompactionTestEnd\n\n");
}
void RLog::CreateL(RFs& aFs, const TDesC& aFile)
{
#ifdef __WINS__
User::LeaveIfError(iLog.Replace(aFs, aFile, EFileWrite));
#endif
}
void RLog::Close()
{
iLog.Close();
}
void RLog::PrintL(const char* aFormat, ...)
{
VA_LIST list;
VA_START(list,aFormat);
TBuf8<256> b;
b.FormatList(_L8(aFormat),list);
VA_END(list);
#ifdef __WINS__
iLog.WriteL(b);
#endif
TBuf<256> b16;
b16.Copy(b);
test.Printf(_L("%S"),&b16);
}
void GetOpt()
{
TBuf<256> options;
User::CommandLine(options);
if (options.Length() > 0)
{
AllTests = EFalse;
TLex lex(options);
lex.SkipSpace();
if (lex.Val(DataVolume) == KErrNone)
{
lex.SkipSpace();
if (lex.Val(Iterations) == KErrNone)
{
lex.SkipSpace();
lex.Val(CompactFrequency);
}
}
}
TheResultsFile.Format(KResultsFile,DataVolume);
}
void testCompactL()
{
GetOpt();
TheLog.CreateL(TheFs, TheResultsFile);
if (AllTests)
{
BasicCompactionTestsL();
if (AllocationFailure())
CompactionAlgorithmTestL();
}
CompactionTestL(Iterations, DataVolume<<10, 300, 5, CompactFrequency);
TheLog.Close();
}
LOCAL_C void setupTestDirectory()
//
// Prepare the test directory.
//
{
TInt r=TheFs.Connect();
test(r==KErrNone);
//
TDriveUnit drive(static_cast<TUint>(RFs::GetSystemDrive()));
TParse parse;
parse.Set(drive.Name(), &KFileLocationSpec, NULL);
r=TheFs.MkDir(parse.DriveAndPath());
test(r==KErrNone||r==KErrAlreadyExists);
r=TheFs.SetSessionPath(parse.DriveAndPath());
test(r==KErrNone);
}
LOCAL_C void setupCleanup()
//
// Initialise the cleanup stack.
//
{
TheTrapCleanup=CTrapCleanup::New();
test(TheTrapCleanup!=NULL);
TRAPD(r,\
{\
for (TInt i=KTestCleanupStack;i>0;i--)\
CleanupStack::PushL((TAny*)0);\
CleanupStack::Pop(KTestCleanupStack);\
});
test(r==KErrNone);
}
LOCAL_C void DeleteDataFile(const TDesC& aFullName)
{
RFs fsSession;
TInt err = fsSession.Connect();
if(err == KErrNone)
{
TEntry entry;
if(fsSession.Entry(aFullName, entry) == KErrNone)
{
test.Printf(_L("Deleting \"%S\" file.\n"), &aFullName);
err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);
if(err != KErrNone)
{
test.Printf(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);
}
err = fsSession.Delete(aFullName);
if(err != KErrNone)
{
test.Printf(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);
}
}
fsSession.Close();
}
else
{
test.Printf(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);
}
}
class CTestStreamStore : public CStreamStore
{
public:
static CTestStreamStore* NewL();
virtual ~CTestStreamStore();
private:
CTestStreamStore();
virtual MStreamBuf* DoReadL(TStreamId anId) const;
virtual MStreamBuf* DoCreateL(TStreamId& anId);
};
CTestStreamStore* CTestStreamStore::NewL()
{
return new (ELeave) CTestStreamStore;
}
CTestStreamStore::~CTestStreamStore()
{
}
CTestStreamStore::CTestStreamStore()
{
}
MStreamBuf* CTestStreamStore::DoReadL(TStreamId) const
{
return NULL;
}
MStreamBuf* CTestStreamStore::DoCreateL(TStreamId&)
{
return NULL;
}
/**
@SYMTestCaseID PDS-STORE-CT-4063
@SYMTestCaseDesc CStreamStore tests.
@SYMTestActions CStreamStore provides couple of virtual methods in its private section:
DoExtendL(), DoDeleteL(), DoReplaceL(), DoReclaimL().
They are no-ops and are expected to be overriden in the class derived from
CStreamStore. Their implementations leave with KErrNotsupported.
The test uses a class derived from CStreamStore, which class does not implement
virtuals mentioned above. These virtuals should leave with KErrNotSupported when called.
@SYMTestPriority High
@SYMTestExpectedResults Test must not fail
*/
void TestStreamStoreVirtualsL()
{
CTestStreamStore* store = CTestStreamStore::NewL();
TRAPD(err, store->CommitL());
test(err == KErrNone);
TRAP(err, store->RevertL());
test(err == KErrNotSupported);
TRAP(err, store->ReclaimL());
test(err == KErrNotSupported);
TRAP(err, store->CompactL());
test(err == KErrNotSupported);
TRAP(err, store->DeleteL(TStreamId(1)));
test(err == KErrNotSupported);
delete store;
}
//
// Test permanent file store.
//
GLDEF_C TInt E32Main()
{
test.Title();
setupTestDirectory();
setupCleanup();
__UHEAP_MARK;
//
test.Start(_L("Test compaction"));
TRAPD(r,testCompactL());
test(r==KErrNone);
test.Next(_L("@SYMTestCaseID:PDS-STORE-CT-4063: Test CStreamStore virtuals"));
TRAP(r, TestStreamStoreVirtualsL())
test(r==KErrNone);
//deletion of data files must be before call to .End() - DEF047652
TDriveUnit drive(static_cast<TUint>(RFs::GetSystemDrive()));
TParse parse;
parse.Set(drive.Name(), &KFileLocationSpec, NULL);
::DeleteDataFile(parse.FullName());
test.End();
//
__UHEAP_MARKEND;
delete TheTrapCleanup;
TheFs.Close();
test.Close();
return 0;
}