diff -r 000000000000 -r bde4ae8d615e os/persistentdata/persistentstorage/centralrepository/pccenrep/test/common.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/persistentdata/persistentstorage/centralrepository/pccenrep/test/common.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,505 @@ +// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include +#include "../../test/t_cenrep_helper.h" +#include + +#ifdef __TOOLS2__ +#define CENREP_PC_TEST +#endif + +#ifdef CENREP_PC_TEST + #include +#else + #include +#endif + +_LIT( KCentralRepositoryServerName, "Centralrepositorysrv"); + + +//DEFINED IN THE TEST MAIN CPP +extern void SetupEnv(const TDesC& aInFilePath,const TDesC& aOutFilePath,TUint aTestMode); +extern void InitialiseLC(CRepository*& aRepository,TUid aUid,const TDesC& aInFilePath,const TDesC& aOutFilePath,TUint aTestMode); +extern RFs TheFs; +extern RTest TheTest; + +LOCAL_C void Check(TInt aValue, TInt aLine) + { + if(!aValue) + { + TheTest(EFalse, aLine); + } + } + +LOCAL_C void Check(TInt aValue, TInt aExpected, TInt aLine) + { + if(aValue != aExpected) + { + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue); + TheTest(EFalse, aLine); + } + } + +#define TEST(arg) ::Check((arg), __LINE__) +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__) + +/////////////////////////////////////////////////////////////////////////////////////// +TInt CopyFile(const TDesC& aSource, const TDesC& aTarget) + { + RFile file; + TInt ret=file.Open(TheFs,aSource,EFileRead); + if (ret!=KErrNone) + return ret; + TInt fileSize; + file.Size(fileSize); + HBufC8* buf=HBufC8::New(fileSize); + if (!buf) + { + file.Close(); + return KErrNoMemory; + } + TPtr8 mod(buf->Des()); + file.Read(mod); + file.Close(); + ret=file.Replace(TheFs,aTarget,EFileWrite); + if (ret==KErrNone) + { + file.Write(*buf); + } + file.Close(); + delete buf; + return ret; + } + +void OomTest(void (*testFuncL)(CRepository* aRepository),TUid aUid,const TDesC& aInFilePath,const TDesC& aOutFilePath,TUint aTestMode) + { + TInt error; + TInt count = 0; + + do + { + SetupEnv(aInFilePath,aOutFilePath,aTestMode); + //for CRE testing we need to ensure we have a fresh copy of CRE(sourced from the TXT template) + + __UHEAP_MARK; + CRepository* repository=NULL; + +#ifndef CENREP_PC_TEST + //for CS testing, we want to kill server to start with fresh repos, otherwise might still use + //cache version from previous test + KillProcess(KCentralRepositoryServerName); +#endif + InitialiseLC(repository,aUid,aInFilePath,aOutFilePath,aTestMode); + if (repository) + CleanupStack::Pop(); + // This is supported by symuser but still have problem, so skiped +// User::__DbgSetAllocFail(RHeap::EUser, RHeap::EDeterministic, ++count); + + + // find out the number of open handles + // TOOLS2 somehow not supporting RThread().HandleCount()? +#ifndef __TOOLS2__ + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); +#endif + + TRAP(error, (testFuncL)(repository)); + + // check that no handles have leaked +#ifndef __TOOLS2__ + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + TEST2(endProcessHandleCount, startProcessHandleCount); + TEST2(endThreadHandleCount, startThreadHandleCount); +#endif +// User::__DbgSetAllocFail(RHeap::EUser, RHeap::ENone, 1); + + delete repository; + + __UHEAP_MARKEND; + + } while(error == KErrNoMemory); + _LIT(KTestFailed, "Out of memory test failure on iteration %d\n"); + __ASSERT_ALWAYS(error==KErrNone, TheTest.Panic(error, KTestFailed, count)); + } + +void ObjectCreateDeleteOOM(TUid aUid,const TDesC& aInFilePath,const TDesC& aOutFilePath,TUint aTestMode) + { +// TInt count=0; + TInt error=KErrNone; + do + { + SetupEnv(aInFilePath,aOutFilePath,aTestMode); + + __UHEAP_MARK; +#ifndef __TOOLS2__ + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); +#endif + // This is supported by symuser but still has problems, so skipped. +// User::__DbgSetAllocFail(RHeap::EUser, RHeap::EDeterministic, ++count); + + CRepository* repository=NULL; + + TRAP(error,InitialiseLC(repository,aUid,aInFilePath,aOutFilePath,aTestMode);CleanupStack::Pop()); + + delete repository; + +// User::__DbgSetAllocFail(RHeap::EUser, RHeap::ENone, 1); + +#ifndef __TOOLS2__ + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + TEST2(endProcessHandleCount, startProcessHandleCount); + TEST2(endThreadHandleCount, startThreadHandleCount); +#endif + + __UHEAP_MARKEND; + } while(error == KErrNoMemory); + } + +void GetFunctionL(CRepository* aRepository) + { + //[GET] + TInt intVal; + TReal realVal; + User::LeaveIfError(aRepository->Get(6,intVal)); + TEST(intVal==12); + User::LeaveIfError(aRepository->Get(8,realVal)); + TEST(realVal==1.5); + TBuf<255> stringVal; + User::LeaveIfError(aRepository->Get(0x300,stringVal)); + TEST(stringVal.Compare(_L("Hello World"))==0); + + TBuf<5> shortBuffer; + TInt actualLength=0; + TInt ret=aRepository->Get(0x300,shortBuffer,actualLength); + TEST(ret==KErrOverflow); + TEST(actualLength==11); + TEST(shortBuffer.Compare(_L("Hello"))==0); + + //[GETMETA] + TUint32 metaValue; + User::LeaveIfError(aRepository->GetMeta(2,metaValue)); + TEST(metaValue==0xa); + //range based + User::LeaveIfError(aRepository->GetMeta(0x204,metaValue)); + TEST(metaValue==0x20); + //default based + User::LeaveIfError(aRepository->GetMeta(0x10000,metaValue)); + TEST(metaValue==0x10); + } + +void FindFunctionL(CRepository* aRepository) + { + RArray keyList; + CleanupClosePushL(keyList); + //Find all settings + TInt ret=aRepository->FindL(0xFFFFFFFF,0,keyList); + User::LeaveIfError(ret); + TEST(ret==KErrNone); + TEST(keyList.Count()==33); + keyList.Reset(); + //Find match EQ specific value + ret=aRepository->FindEqL(0xFFFFFFFF,0,10,keyList); + User::LeaveIfError(ret); + TEST(ret==KErrNone); + TEST(keyList.Count()==3); + keyList.Reset(); + //Find match NEQ specific value + ret=aRepository->FindNeqL(0xFFFFFFFF,0,10,keyList); + TEST(ret==KErrNone); + TEST(keyList.Count()==30); + keyList.Reset(); + //Find using string matching instead + _LIT(KString,"empty"); + ret=aRepository->FindEqL(0xFFFFFFFF,0,KString(),keyList); + User::LeaveIfError(ret); + TEST(ret==KErrNone); + TEST(keyList.Count()==1); + CleanupStack::PopAndDestroy(); + } + +void SetFunctionL(CRepository* aRepository) + { + //[SET] + //int + TUint32 metaValue; + TInt value; + User::LeaveIfError(aRepository->Get(1,value)); + TEST(value==1); + User::LeaveIfError(aRepository->Set(1,100)); + User::LeaveIfError(aRepository->Get(1,value)); + TEST(value==100) ; + //real + TReal realValue; + User::LeaveIfError(aRepository->Get(2,realValue)); + TEST(realValue==2.732); + TReal newrealValue(5.464); + User::LeaveIfError(aRepository->Set(2,newrealValue)); + User::LeaveIfError(aRepository->Get(2,realValue)); + TEST(realValue==5.464); + //string + TBuf<255> stringValue; + User::LeaveIfError(aRepository->Get(0x10000,stringValue)); + TEST(stringValue.Compare(_L("empty"))==0); + User::LeaveIfError(aRepository->Set(0x10000,_L("full"))); + stringValue.Zero(); + User::LeaveIfError(aRepository->Get(0x10000,stringValue)); + TEST(stringValue.Compare(_L("full"))==0); + + //use set to create new setting and also check the meta + TInt newIntegerKeyValue=205; + User::LeaveIfError(aRepository->Set(0x205,newIntegerKeyValue)); + User::LeaveIfError(aRepository->Get(0x205,value)); + TEST(value==205); + User::LeaveIfError(aRepository->GetMeta(0x205,metaValue)); + //as the key 0x205 is within range, expect use of range meta + TEST(metaValue==0x20); + } + +void CreateFunctionL(CRepository* aRepository) + { + TUint32 metaValue; + TInt value=206; + User::LeaveIfError(aRepository->Create(0x206,value)); + User::LeaveIfError(aRepository->Get(0x206,value)); + TEST(value==206); + User::LeaveIfError(aRepository->GetMeta(0x206,metaValue)); + //within meta range + TEST(metaValue==0x20); + + TReal realValue=207.207; + User::LeaveIfError(aRepository->Create(0x407,realValue)); + User::LeaveIfError(aRepository->Get(0x407,realValue)); + TEST(realValue==207.207); + User::LeaveIfError(aRepository->GetMeta(0x407,metaValue)); + //default meta + TEST(metaValue==0x10); + + //create already existing setting + TInt ret=aRepository->Create(1,value); + TEST(ret==KErrAlreadyExists); + } + +void DeleteFunctionL(CRepository* aRepository) + { + //delete single + TInt value; + User::LeaveIfError(aRepository->Delete(6)); + TInt ret=aRepository->Get(6,value); + TEST(ret==KErrNotFound); + + //delete range + RArray keyList; + CleanupClosePushL(keyList); + //make sure that the list of keys are there first + ret=aRepository->FindL(0x03010000,0xFFFFF0FF,keyList); + User::LeaveIfError(ret); + TEST(keyList.Count()==5); + TUint32 error; + User::LeaveIfError(aRepository->Delete(0x03010000,0xFFFFF0FF,error)); + //check that key no longer exist + keyList.Reset(); + ret=aRepository->FindL(0x03010000,0xFFFFF0FF,keyList); + if (ret!=KErrNotFound) + User::LeaveIfError(ret); + TEST(ret==KErrNotFound); + TEST(keyList.Count()==0); + CleanupStack::PopAndDestroy(); + } + +void MoveFunctionL(CRepository* aRepository) + { + RArray keyList; + CleanupClosePushL(keyList); + TUint32 errorKey; + //check source key exists first + keyList.Reset(); + TInt ret=aRepository->FindL(0x02010000,0xFFFFF0FF,keyList); + User::LeaveIfError(ret); + TEST(keyList.Count()==5); + + User::LeaveIfError(aRepository->Move(0x02010000,0x06010000,0xFFFFF0FF,errorKey)); + + keyList.Reset(); + //check target now exists + ret=aRepository->FindL(0x06010000,0xFFFFF0FF,keyList); + User::LeaveIfError(ret); + + TEST(keyList.Count()==5); + //check source now deleted + keyList.Reset(); + ret=aRepository->FindL(0x02010000,0xFFFFF0FF,keyList); + TEST(ret==KErrNotFound); + TEST2(keyList.Count(),0); + + CleanupStack::PopAndDestroy(); + } + +/** +*/ +void BasicFunctionL(TUid aUid,const TDesC& aInFilePath,const TDesC& aOutFilePath,TUint aTestMode) + { + //TEST SETUP + SetupEnv(aInFilePath,aOutFilePath,aTestMode); + + __UHEAP_MARK; + CRepository* repository=NULL; + + InitialiseLC(repository,aUid,aInFilePath,aOutFilePath,aTestMode); + +#ifdef CENREP_PC_TEST + //testing transaction + TInt r= repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction); + TEST2(r, KErrNone); + repository->CleanupCancelTransactionPushL(); +#endif + + GetFunctionL(repository); + FindFunctionL(repository); + SetFunctionL(repository); + CreateFunctionL(repository); + DeleteFunctionL(repository); + MoveFunctionL(repository); + +#ifdef CENREP_PC_TEST + CleanupStack::PopAndDestroy(); +#endif + + CleanupStack::PopAndDestroy(); + + __UHEAP_MARKEND; + } + +void OomBasicFunction(TUid aUid,const TDesC& aInFilePath,const TDesC& aOutFilePath,TUint aTestMode) + { + __UHEAP_MARK; + + OomTest(GetFunctionL,aUid,aInFilePath,aOutFilePath,aTestMode); + OomTest(FindFunctionL,aUid,aInFilePath,aOutFilePath,aTestMode); + OomTest(SetFunctionL,aUid,aInFilePath,aOutFilePath,aTestMode); + OomTest(CreateFunctionL,aUid,aInFilePath,aOutFilePath,aTestMode); + OomTest(DeleteFunctionL,aUid,aInFilePath,aOutFilePath,aTestMode); + OomTest(MoveFunctionL,aUid,aInFilePath,aOutFilePath,aTestMode); + + __UHEAP_MARKEND; + } + +void DEF130394L(TUid aUid) + { + CRepository* repos=NULL; + + repos = CRepository::NewL(aUid); + + TInt err = repos->Create(1,1); + TEST(err==KErrNone); + + delete repos; + + repos = CRepository::NewL(aUid); + + err = repos->Create(1,1); + TEST(err==KErrAlreadyExists); + + delete repos; + } + +void DoFileCompL(const TDesC& aGenerated, const TDesC& aReference, TUint32& aCrcValue) + { + RFile genFile; + RFile refFile; + TInt err = genFile.Open(TheFs,aGenerated,EFileRead); + User::LeaveIfError(err); + err = refFile.Open(TheFs,aReference,EFileRead); + User::LeaveIfError(err); + + TInt sizeOfGen; + genFile.Size(sizeOfGen); + TInt sizeOfRef; + refFile.Size(sizeOfRef); + TEST(sizeOfGen == sizeOfRef); + + TUint32 crcGen = 0; + TUint32 crcRef = 0; + + HBufC8* buf = HBufC8::New(sizeOfGen); + if (!buf) + { + genFile.Close(); + refFile.Close(); + User::Leave(KErrNoMemory); + } + TPtr8 data(buf->Des()); + + err = genFile.Read(data); + User::LeaveIfError(err); + Mem::Crc32(crcGen, buf, sizeOfGen); + err = refFile.Read(data); + User::LeaveIfError(err); + Mem::Crc32(crcRef, buf, sizeOfRef); + + TEST(crcGen == crcRef); + + aCrcValue = crcGen; + + delete buf; + genFile.Close(); + refFile.Close(); + + return; + } + +void DoCrcCompL(const TUint32& aCrcValue, const TDesC& aCrcRecord, TBool aCreOrTxt) + { + RFile file; + TInt err = file.Open(TheFs, aCrcRecord, EFileRead); + User::LeaveIfError(err); + + TBuf8<100> buf; + file.Read(buf); + + TBuf8<1> breaker(_L8("-")); + TInt pos = buf.Find(breaker); + + TInt length = buf.Length(); + + const TPtrC8 crePtr = buf.Right(length - pos -1); + const TPtrC8 txtPtr = buf.Left(pos); + + TUint32 crc = 0; + + if (aCreOrTxt) + { + TLex8 lex (crePtr); + lex.Val(crc, EDecimal); + } + else + { + TLex8 lex (txtPtr); + lex.Val(crc, EDecimal); + } + TEST2(crc, aCrcValue); + file.Close(); + } +