diff -r 7d4490026038 -r 44f437012c90 persistentstorage/centralrepository/test/t_cenrep_pma_oom.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/persistentstorage/centralrepository/test/t_cenrep_pma_oom.cpp Tue Oct 19 16:26:13 2010 +0100 @@ -0,0 +1,1335 @@ +// Copyright (c) 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 "t_cenrep_helper.h" +#include +#include +#include +#include "srvsess.h" +#include "sessmgr.h" +#include "srvres.h" +#include "srvreqs.h" +#include "cachemgr.h" +#include "clientrequest.h" +#include "install.h" +#include + +LOCAL_D RTest TheTest(_L("t_cenrep_pma_oom.exe")); + +_LIT( KCentralRepositoryServerName, "Centralrepositorysrv"); + +_LIT(KInstallDirFile, "c:\\private\\10202BE9\\persists\\installdir.bin"); + +_LIT(KInstallPMATxtFileSrc, "z:\\private\\10202BE9\\f1000701.txi"); +_LIT(KInstallPMATxtFileTgt, "c:\\private\\10202BE9\\f1000701.txt"); + +_LIT(KInstallPMACreFileSrc, "z:\\private\\10202BE9\\f1000700.cri"); +_LIT(KInstallPMACreFileTgt, "c:\\private\\10202BE9\\f1000700.cre"); + +//Test repositories Uid +const TUid KTestRepositoryUid={0xf1000701}; + +static TUid KCurrentTestUid; + +//Burst rate for __UHEAP_SETBURSTFAIL +#ifdef _DEBUG +const TInt KBurstRate = 20; +#endif + +/////////////////////////////////////////////////////////////////////////////////////// +//Test macros and functions +LOCAL_C void Check(TInt aValue, TInt aLine) + { + if(!aValue) + { + TRAPD(err, CleanupCDriveL()); + if (err != KErrNone) + { + RDebug::Print( _L( "*** CleanupCDriveL also failed with error %d expecting KErrNone\r\n"), err ); + } + TheTest(EFalse, aLine); + } + } +LOCAL_C void Check(TInt aValue, TInt aExpected, TInt aLine, TBool aIsHexFormat=EFalse) + { + if(aValue != aExpected) + { + if(aIsHexFormat) + { + RDebug::Print(_L("*** Expected error: 0x%x, got: 0x%x\r\n"), aExpected, aValue); + } + else + { + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue); + } + TRAPD(err, CleanupCDriveL()); + if (err != KErrNone) + { + RDebug::Print( _L( "*** CleanupCDriveL also failed with error %d expecting KErrNone\r\n"), err ); + } + TheTest(EFalse, aLine); + } + } +#define TEST(arg) ::Check((arg), __LINE__) +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__) +#define TESTHEX2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__, ETrue) +#define TESTKErrNone(aValue) ::Check(aValue,0,__LINE__); + +/////////////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////////////// +static void CloseTServerResources(TAny*) + { + TServerResources::Close(); + } + +///////////////////////////////////////////////////////////////////////////////////////// +class CenrepSrvOOMTest :public CBase +{ +public: + void GetL(); + void FindL(); + void ResetL(); + void NotifyL(); + void SetL(); + void CreateL(); + void DeleteL(); + void MoveL(); + + CenrepSrvOOMTest(); + ~CenrepSrvOOMTest(); + static CenrepSrvOOMTest* NewL(); +#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS + void DoHeapRepositoryContentCheckL(); +#endif +private: + void ConstructL(); +public: + CServerRepository* iServerRepo; + CSessionNotifier* iSessionNotif; +}; + +////////////////////////////////////////////////////////////////////////////////////////////////// +class CenrepSwiOOMTest :public CBase +{ +public: + void InstallTxtPmaL(TBool aIsSetup); + void InstallCrePmaL(TBool aIsSetup); + + CenrepSwiOOMTest(); + ~CenrepSwiOOMTest(); + static CenrepSwiOOMTest* NewL(); +private: + void ConstructL(); + CCentRepSWIWatcher* iSwiWatcher; +public: +}; +////////////////////////////////////////////////////////////////////////////////////////////////// + +CenrepSrvOOMTest::CenrepSrvOOMTest(){} + +CenrepSrvOOMTest::~CenrepSrvOOMTest() + { + if(iServerRepo) + { + if(iSessionNotif) + { + iServerRepo->Close(); + } + delete iServerRepo; + } + if(iSessionNotif) + { + delete iSessionNotif; + } + + // Cache must be disabled here. Otherwise, if any idle repositories exists, they will + // still be open (have their pointers in the iOpenRepositories list) and the list will leak. + TServerResources::iCacheManager->DisableCache(); + TServerResources::iObserver->CloseiOpenRepositories(); + } + +CenrepSrvOOMTest* CenrepSrvOOMTest::NewL() + { + CenrepSrvOOMTest* self=new (ELeave)CenrepSrvOOMTest; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void CenrepSrvOOMTest::ConstructL() + { + iServerRepo=new (ELeave)CServerRepository(); + iSessionNotif=new (ELeave) CSessionNotifier(); + + iServerRepo->OpenL(KCurrentTestUid,*iSessionNotif); + } + +////////////////////////////////////////////////////////////////////////////////////////////////// + +CenrepSwiOOMTest::CenrepSwiOOMTest(){} + +CenrepSwiOOMTest::~CenrepSwiOOMTest() + { + delete iSwiWatcher; + } + +CenrepSwiOOMTest* CenrepSwiOOMTest::NewL() + { + CenrepSwiOOMTest* self=new (ELeave)CenrepSwiOOMTest; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void CenrepSwiOOMTest::ConstructL() + { + iSwiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs); + } + +//Getting various information and security policy from the repository +//TInt CServerRepository::Get(TUint32 aId,T& aVal) +//TServerSetting* CServerRepository::GetSetting(TUint32 aId) +void CenrepSrvOOMTest::GetL() + { + TInt err=KErrNone; + TInt keyInt=0; + TServerSetting* srvsetting; + //----------Getting the TInt(1-15)----------------------------- + for(TInt i=1;i<=15;i++) + { + err=iServerRepo->Get(i,keyInt); + //Remember the policy check is done at the session level + TESTKErrNone(err); + TEST2(i,keyInt); + srvsetting=iServerRepo->GetSetting(i); + TEST(srvsetting->Key()==static_cast(i)); + } + //---------Getting the TReal(16-19)--------------------------- + TReal keyValue; + err=iServerRepo->Get(16,keyValue); + TESTKErrNone(err); + TEST(keyValue==10.1010); + srvsetting=iServerRepo->GetSetting(16); + TESTHEX2(srvsetting->Key(),16); + + err=iServerRepo->Get(19,keyValue); + TESTKErrNone(err); + TEST(keyValue==13.1313); + + //----------Getting the String(20-23)----------------------- + TBuf8<50> keyString; + _LIT(KFourteen,"fourteen"); + err=iServerRepo->Get(20,keyString); + TESTKErrNone(err); + //Even ascii(8 bytes) are stored as 16 bytes!!! + TPtr16 str16((TUint16*) keyString.Ptr(),keyString.Length()/2,keyString.Length()/2); + TEST(str16.Compare(KFourteen)==0); + srvsetting=iServerRepo->GetSetting(20); + TESTHEX2(srvsetting->Key(),20); + + //---------Getting the String8(0x79)------------------------ + TBuf8<50> keyString8; + _LIT8(KString8,"string8"); + err=iServerRepo->Get(0x79,keyString8); + TESTKErrNone(err); + TEST(keyString8.Compare(KString8)==0); + srvsetting=iServerRepo->GetSetting(0x79); + TESTHEX2(srvsetting->Key(),0x79); + + //---------Getting the binary(0x82)------------------------- + TBuf8<50> keyBinary; + _LIT8(KBinary8,"\x12\x34\xAB\xCD"); + err=iServerRepo->Get(0x82,keyBinary); + TESTKErrNone(err); + //temporarily added to solve coverage problem in WINSCW + TEST(keyBinary.Compare(KBinary8)==0); + srvsetting=iServerRepo->GetSetting(0x82); + TESTHEX2(srvsetting->Key(),0x82); + + //----------Getting individual policy----------------------- + //Current Exe has caps AllFiles+WriteDeviceData+ReadDeviceData + RThread currentThread; + TSecurityPolicy secPolicy; + //default policy + secPolicy=iServerRepo->GetDefaultReadAccessPolicy(); + TEST(secPolicy.CheckPolicy(currentThread)==1); + secPolicy=iServerRepo->GetDefaultWriteAccessPolicy(); + TEST(secPolicy.CheckPolicy(currentThread)==1); + + //check settings policies + //0x2 int 2 1 cap_rd=CommDD cap_wr=WriteDeviceData + //0x19 int 25 0 //defined in range policies with cap_rd=NetworkServices + secPolicy=iServerRepo->GetReadAccessPolicy(2); + TEST(secPolicy.CheckPolicy(currentThread)==0); + secPolicy=iServerRepo->GetWriteAccessPolicy(2); + TEST(secPolicy.CheckPolicy(currentThread)==1); + secPolicy=iServerRepo->GetReadAccessPolicy(25); + TEST(secPolicy.CheckPolicy(currentThread)==0); + + } + +// now that write operations must be done in transactions, setting up this helper +// function to perform single Sets for the purpose of this test. +template +static TInt RepositorySingleSetL(CServerRepository& aRep, TUint32 aKey, const T& aValue) + { + aRep.StartTransaction(EConcurrentReadWriteTransaction); + aRep.CleanupCancelTransactionPushL(); + aRep.TransactionSetL(aKey, aValue); + CleanupStack::Pop(); + TUint32 keyInfo; + return User::LeaveIfError(aRep.CommitTransaction(keyInfo)); + }; + +//Setting OOM testing +void CenrepSrvOOMTest::SetL() + { + TInt ret=KErrNone; + TInt intValue=0; + TReal realValue=0; + + //---------------SetL----------------------------------- + //Setting an integer key + ret = RepositorySingleSetL(*iServerRepo, 0x60, 600); + TESTKErrNone(ret); + ret=iServerRepo->Get(0x60,intValue); + TESTHEX2(intValue, 600); + + //Setting a real key + ret = RepositorySingleSetL(*iServerRepo, 0x66, 99.99); + TESTKErrNone(ret); + ret=iServerRepo->Get(0x66,realValue); + TEST(realValue==99.99); + + //Setting a string key + //Even ascii(8 bytes) are stored as 16 bytes!!! + _LIT8(KString,"sixhundred"); + TBuf8<50> stringChangeValue=KString(); + ret = RepositorySingleSetL(*iServerRepo, 0x69, stringChangeValue); + TESTKErrNone(ret); + + TBuf8<50> keyString; + ret=iServerRepo->Get(0x69,keyString); + TESTKErrNone(ret); + TEST(keyString.Compare(KString)==0); + } + +// now that write operations must be done in transactions, setting up this helper +// function to perform single Creates for the purpose of this test. +template +static TInt RepositorySingleCreateL(CServerRepository& aRep, TUint32 aKey, const T& aValue, TUint32* aMeta) + { + aRep.StartTransaction(EConcurrentReadWriteTransaction); + aRep.CleanupCancelTransactionPushL(); + aRep.TransactionCreateL(aKey, aValue, aMeta); + CleanupStack::Pop(); + TUint32 keyInfo; + return User::LeaveIfError(aRep.CommitTransaction(keyInfo)); + }; + +void CenrepSrvOOMTest::CreateL() + { + TInt ret=KErrNone; + TInt intValue=0; + TReal realValue=0; + + //--------------CreateL----------------------------------- + //Creating an integer key + TInt intRetValue; + intValue=9000; + RepositorySingleCreateL(*iServerRepo, 0x90, intValue, NULL); + TESTKErrNone(ret); + ret=iServerRepo->Get(0x90,intRetValue); + TESTKErrNone(ret); + TESTHEX2(intRetValue, intValue); + + //Creating a real key + TReal realRetValue; + realValue=33.3333; + RepositorySingleCreateL(*iServerRepo, 0x92, realValue, NULL); + TESTKErrNone(ret); + ret=iServerRepo->Get(0x92,realRetValue); + TESTKErrNone(ret); + TEST(realValue==realRetValue); + + //Creating a string key + _LIT8(KStringValue,"creatingkey"); + TBuf8<50> stringCreateValue=KStringValue(); + RepositorySingleCreateL(*iServerRepo, 0x93, stringCreateValue, NULL); + TESTKErrNone(ret); + } + +// now that write operations must be done in transactions, setting up this helper +// function to perform single Creates for the purpose of this test. +static TInt RepositorySingleDeleteL(CServerRepository& aRep, TUint32 aKey) + { + aRep.StartTransaction(EConcurrentReadWriteTransaction); + aRep.CleanupCancelTransactionPushL(); + aRep.TransactionDeleteL(aKey); + CleanupStack::Pop(); + TUint32 keyInfo; + return User::LeaveIfError(aRep.CommitTransaction(keyInfo)); + }; + +void CenrepSrvOOMTest::DeleteL() + { + TInt ret=KErrNone; + //--------------Delete----------------------------------- + //Find the settings 0x10A-0x10C to ensure it is still there + RSettingPointerArray matchingArray; + TUint32 partialId=0x100; + TUint32 idMask=0xFFFFFFF0; + ret=iServerRepo->FindSettings(partialId,idMask,matchingArray); + if(ret==KErrNoMemory) + { + matchingArray.Close(); + User::LeaveNoMemory(); + } + + TESTKErrNone(ret); + TEST2(matchingArray.Count(),3); + matchingArray.Close(); + + //Deleting settings 0x10A to 0x10C + for(TInt i=0x10A;i<=0x10C;i++) + { + RepositorySingleDeleteL(*iServerRepo, i); + TESTKErrNone(ret); + } + //After deleting try to find the persistent settings again + ret=iServerRepo->FindSettings(partialId,idMask,matchingArray); + if(ret==KErrNoMemory) + { + matchingArray.Close(); + User::LeaveNoMemory(); + } + TESTKErrNone(ret); + TEST2(matchingArray.Count(),0); + matchingArray.Close(); + + //-------------DeleteRange--------------------------------- + //Deleting settings 0x1 to 0xF + TClientRequest dummyrequest; + TUint32 errId=0; + partialId=0; + idMask=0xFFFFFFF0; + ret=iServerRepo->FindSettings(partialId,idMask,matchingArray); + if(ret==KErrNoMemory) + { + matchingArray.Close(); + User::LeaveNoMemory(); + } + TESTKErrNone(ret); + TEST2(matchingArray.Count(),15); + matchingArray.Close(); + + //Deleting settings using the DeleteRange + dummyrequest.SetParam(0,partialId); + dummyrequest.SetParam(1,idMask); + dummyrequest.SetPolicyCheck(ETrue); + + // write operation must take place in a transaction + iServerRepo->StartTransaction(EConcurrentReadWriteTransaction); + iServerRepo->CleanupCancelTransactionPushL(); + iServerRepo->TransactionDeleteRangeL(dummyrequest,errId); + CleanupStack::Pop(); + TUint32 keyInfo; + User::LeaveIfError(iServerRepo->CommitTransaction(keyInfo)); + + //Now try to find the key being deleted + ret=iServerRepo->FindSettings(partialId,idMask,matchingArray); + if(ret==KErrNoMemory) + { + matchingArray.Close(); + User::LeaveNoMemory(); + } + TESTKErrNone(ret); + TEST2(matchingArray.Count(),0); + matchingArray.Close(); + } + +//Setting existing key value then follow by commit +void CenrepSrvOOMTest::MoveL() + { + RSettingPointerArray matchingArray; + TUint32 idMask=0xFFFFFFF0; + + TClientRequest dummyrequest; + TUint32 errId=0; + TUint32 sourcePartialId=0x110; + TUint32 targetPartialId=0x120; + idMask=0xFFFFFFF0; + + TKeyFilter srcKeyIdentifier = {sourcePartialId, idMask}; + TPckg pSrcIdentifier(srcKeyIdentifier); + TKeyFilter tgtKeyIdentifier = {targetPartialId, idMask}; + TPckg pTgtIdentifier(tgtKeyIdentifier); + + //First check to ensure the target key before move does not exist + User::LeaveIfError(iServerRepo->FindSettings(targetPartialId,idMask,matchingArray)); + TEST2(matchingArray.Count(),0); + matchingArray.Close(); + + //moving from 0x110(0x11B,0x11C,0x11E) to 0x120 + dummyrequest.SetParam(0, &pSrcIdentifier); + dummyrequest.SetParam(1, &pTgtIdentifier); + dummyrequest.SetPolicyCheck(ETrue); + + // write operation must take place in a transaction + User::LeaveIfError(iServerRepo->StartTransaction(EConcurrentReadWriteTransaction)); + iServerRepo->CleanupCancelTransactionPushL(); + User::LeaveIfError(iServerRepo->TransactionMoveL(dummyrequest,errId)); + CleanupStack::Pop(); + TUint32 keyInfo; + User::LeaveIfError(iServerRepo->CommitTransaction(keyInfo)); + + //Now try to find the key being moved + User::LeaveIfError(iServerRepo->FindSettings(targetPartialId,idMask,matchingArray)); + TEST2(matchingArray.Count(),3); + matchingArray.Close(); + } + +//Finding keys from the settings +//TInt FindSettings(TUint32 aPartialId,TUint32 aIdMask,RSettingPointerArray& aMatches) +//Guarantees the heap free in aMatches if this function fail +void CenrepSrvOOMTest::FindL() + { + TInt ret=KErrNone; + RSettingPointerArray foundIdArray; + TUint32 partialId=0; + TUint32 idMask=0; + //-----------Finding settings array using partial id & mask------ + + //------------------Real type--------------------------------- + //0x42,0x44,0x45,0x48 + partialId=0x40; + idMask=0xFFFFFFF0; + User::LeaveIfError(iServerRepo->FindSettings(partialId,idMask,foundIdArray)); + TESTKErrNone(ret); + TEST2(foundIdArray.Count(),4); + foundIdArray.Close(); + + //-----------------String type------------------------------- + //0x51,0x54,0x5B + partialId=0x50; + idMask=0xFFFFFFF0; + User::LeaveIfError(iServerRepo->FindSettings(partialId,idMask,foundIdArray)); + TESTKErrNone(ret); + TEST2(foundIdArray.Count(),3); + foundIdArray.Close(); + + //--------------------Int type---------------------------------------------------- + partialId=0x30; + idMask=0xFFFFFFF0; + //This should return only 0x30,0x34,0x35,0x39,0x3B( 5 items) + User::LeaveIfError(iServerRepo->FindSettings(partialId,idMask,foundIdArray)); + TESTKErrNone(ret); + TEST2(foundIdArray.Count(),5); + + //----------------Find comparison using EEqual & ENotEqual------------------------ + TInt searchValue=100; + TClientRequest dummyrequest; + RArray idArray; + //Set the policycheck to always pass + dummyrequest.SetPolicyCheck(ETrue); + //Comparison using Equal + TRAP(ret,iServerRepo->FindCompareL(foundIdArray,searchValue,EEqual,idArray)); + if(ret==KErrNoMemory) + { + //do not need to reset idArray as it is done inside the function itself when it returns not KErrNone + foundIdArray.Close(); + User::LeaveNoMemory(); + } + TEST2(idArray.Count(),2); + TEST((idArray[0]==0x30 && idArray[1]==0x34) || (idArray[0]==0x34 && idArray[1]==0x30)); + idArray.Close(); + //Comparison using ENotEqual + TRAP(ret,iServerRepo->FindCompareL(foundIdArray,searchValue,ENotEqual,idArray)); + if(ret==KErrNoMemory) + { + //do not need to reset idArray as it is done inside the function itself when it returns not KErrNone + foundIdArray.Close(); + User::LeaveNoMemory(); + } + TEST2(idArray.Count(),3); + idArray.Close(); + foundIdArray.Close(); + + } + +//Resetting settings +void CenrepSrvOOMTest::ResetL() + { + TInt ret=KErrNone; + TInt retValue=0; + TReal realValue=0; + + //-------------Single key reset---------------------------- + + ret = RepositorySingleSetL(*iServerRepo, 1, 500); + TESTKErrNone(ret); + ret=iServerRepo->Get(1,retValue); + TESTHEX2(retValue, 500); + + //Resetting individual settings + ret=iServerRepo->ResetL(1); + TEST2(ret, KErrNotSupported); + + //Check for value once being reset + ret=iServerRepo->Get(1,retValue); + TEST(retValue==500); + + //------------All keys reset------------------------------ + ret = RepositorySingleSetL(*iServerRepo, 17, 3.1343424); + TESTKErrNone(ret); + + //Reset all settings from Rom + ret = iServerRepo->ResetAllL(); + TEST2(ret, KErrNotSupported); + + //Check for value once all being reset + + ret=iServerRepo->Get(17,realValue); + TEST(realValue==3.1343424); + } + +void CenrepSrvOOMTest::NotifyL() + { + TInt err=KErrNone; + + //addding individual requests + for(TInt i=0;i<10;i++) + { + TClientRequest dummyRequest; + User::LeaveIfError(iSessionNotif->AddRequest(i,dummyRequest)); + } + + //adding group requests + for(TInt i=0;i<10;i++) + { + TClientRequest dummyRequest; + TUint32 partialId=100*i; + TUint32 idMask=0xFFFFFFF0; + User::LeaveIfError(iSessionNotif->AddRequest(partialId,idMask,dummyRequest)); + } + + //cancelling individual requests + User::LeaveIfError(iSessionNotif->CancelRequest(5)); + //Check to ensure that it has been deleted so calling cancel again will return KErrNotFound + err=iSessionNotif->CancelRequest(5); + TEST2(err,KErrNotFound); + + //cancelling group requests + User::LeaveIfError(iSessionNotif->CancelRequest(500,0xFFFFFFF0)); + err=iSessionNotif->CancelRequest(500,0xFFFFFF0); + TEST2(err,KErrNotFound); + + //Finally cancel ALL requests + iSessionNotif->CancelAllRequests(); + + } + +//Deletes the CServerRepository object properly +LOCAL_C void ReleaseRepository(TAny* aServerRepository) + { + CServerRepository* serverRepository = static_cast(aServerRepository); + + TServerResources::iCacheManager->DisableCache(); + TServerResources::iObserver->CloseiOpenRepositories(); + delete serverRepository; + TServerResources::iCacheManager->EnableCache(); + } + +//Opening a repository and closing the repository +LOCAL_C void OpenCloseL(TBool /*aOOMMode*/) +{ + CServerRepository* serverRepo=new (ELeave)CServerRepository(); + TCleanupItem cleanupItem(&ReleaseRepository, serverRepo); + CleanupStack::PushL(cleanupItem); + + CSessionNotifier* sessNotif=new (ELeave)CSessionNotifier(); + CleanupStack::PushL(sessNotif); + + // test access to a valid repository + serverRepo->OpenL(KCurrentTestUid,*sessNotif); + serverRepo->Close(); + + CleanupStack::PopAndDestroy(sessNotif); + CleanupStack::PopAndDestroy(1); +} + +LOCAL_C void DoMultiRofsReposTestL( TUid aReposUid, const TDesC& aTestDesc, TInt aExpectedResult) + { + + TheTest.Next(aTestDesc); + + TInt err; + TInt tryCount = 0; + KCurrentTestUid = aReposUid; + do + { + __UHEAP_MARK; + + //Initializing the server resources + TServerResources::InitialiseL(); + CleanupStack::PushL(TCleanupItem(CloseTServerResources, 0)); + + // find out the number of open handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + __UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++tryCount, KBurstRate); + + TRAP(err, OpenCloseL(ETrue)); + if(err!=KErrNoMemory) + { + TEST2(err, aExpectedResult); + } + + __UHEAP_RESET; + + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + TEST2(startProcessHandleCount, endProcessHandleCount); + TEST2(startThreadHandleCount, endThreadHandleCount); + + //Freeing the server resources + CleanupStack::Pop(); //CloseTServerResources + TServerResources::Close(); + + __UHEAP_MARKEND; + } while(err == KErrNoMemory); + + TEST2(err, aExpectedResult); + TheTest.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount); + + } + +void CenrepSwiOOMTest::InstallTxtPmaL(TBool aIsSetup) + { + if(aIsSetup) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + CleanupClosePushL(fs); + CFileMan* fm = CFileMan::NewL(fs); + CleanupStack::PushL(fm); + + // Copy a txt PMA keyspace into install dir & Reset read-only bit + // This keyspace also exists in ROM as PMA keyspace + User::LeaveIfError(fm->Copy(KInstallPMATxtFileSrc, KInstallPMATxtFileTgt)); + User::LeaveIfError(fm->Attribs(KInstallPMATxtFileTgt,0,KEntryAttReadOnly,TTime(0))); + + CleanupStack::PopAndDestroy(2); // fs and fm + } + else + { + iSwiWatcher->HandleSWIEventL(ESASwisInstall | ESASwisStatusSuccess); + } + } + +void CenrepSwiOOMTest::InstallCrePmaL(TBool aIsSetup) + { + if(aIsSetup) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + CleanupClosePushL(fs); + CFileMan* fm = CFileMan::NewL(fs); + CleanupStack::PushL(fm); + + // Copy a cre PMA keyspace into install dir & Reset read-only bit + User::LeaveIfError(fm->Copy(KInstallPMACreFileSrc, KInstallPMACreFileTgt)); + User::LeaveIfError(fm->Attribs(KInstallPMACreFileTgt,0,KEntryAttReadOnly,TTime(0))); + + CleanupStack::PopAndDestroy(2); // fs and fm + } + else + { + iSwiWatcher->HandleSWIEventL(ESASwisInstall | ESASwisStatusSuccess); + } + } + +LOCAL_C void StartupInstallL(TBool aIsSetup) +{ + if(aIsSetup) + { + // Set up files for test + RFs fs; + User::LeaveIfError(fs.Connect()); + CleanupClosePushL(fs); + CFileMan* fm = CFileMan::NewL(fs); + CleanupStack::PushL(fm); + + // Clean out files + TInt err=fs.Delete(KInstallDirFile); + if((err!=KErrNone)&&(err!=KErrNotFound)) + { + User::Leave(err); + } + + // Cause directory listing with no files to be written + CCentRepSWIWatcher* swiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs); + delete swiWatcher; + + // Copy a txt PMA keyspace into install dir & Reset read-only bit + User::LeaveIfError(fm->Copy(KInstallPMATxtFileSrc, KInstallPMATxtFileTgt)); + User::LeaveIfError(fm->Attribs(KInstallPMATxtFileTgt,0,KEntryAttReadOnly,TTime(0))); + + // Copy a cre PMA keyspace into install dir & Reset read-only bit + User::LeaveIfError(fm->Copy(KInstallPMACreFileSrc, KInstallPMACreFileTgt)); + User::LeaveIfError(fm->Attribs(KInstallPMACreFileTgt,0,KEntryAttReadOnly,TTime(0))); + + + CleanupStack::PopAndDestroy(2); // fs and fm + } + else + { + CCentRepSWIWatcher* swiWatcher = CCentRepSWIWatcher::NewL(TServerResources::iFs); + delete swiWatcher; + } +} + +// Type definition for pointer to function +// Used for functions that can't use CenrepSrvOOMTest::ConstructL +typedef void (*FuncPtrL) (TBool); +/** +Wrapper function to call all OOM test functions +@param testFuncL pointer to OOM test function +@param aTestDesc test function name +*/ +LOCAL_C void DoOOMNoServReposL( FuncPtrL atestFuncL, const TDesC& aTestDesc, TBool aOOMMode) + { + TheTest.Next(aTestDesc); + + TInt err; + TInt tryCount = 0; + do + { + __UHEAP_MARK; + + //Initializing the server resources + TServerResources::InitialiseL(); + CleanupStack::PushL(TCleanupItem(CloseTServerResources, 0)); + + // find out the number of open handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + (*atestFuncL)(ETrue); + + if(aOOMMode) + { + __UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++tryCount, KBurstRate); + } + + TRAP(err, (*atestFuncL)(EFalse)); + if(err!=KErrNoMemory) + { + TESTKErrNone(err); + } + + if(aOOMMode) + { + __UHEAP_RESET; + } + + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + TEST2(startProcessHandleCount, endProcessHandleCount); + TEST2(startThreadHandleCount, endThreadHandleCount); + + //Freeing the server resources + CleanupStack::Pop(); //CloseTServerResources + TServerResources::Close(); + + __UHEAP_MARKEND; + } while(err == KErrNoMemory); + + TESTKErrNone(err); + if(aOOMMode) + { + TheTest.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount); + } + } + +// Type definition for pointer to member function. +// Used in calling the CRegistryDataTest member function for testing. +typedef void (CenrepSrvOOMTest::*ClassFuncPtrL) (void); +/** +Wrapper function to call all OOM test functions +@param testFuncL pointer to OOM test function +@param aTestDesc test function name +@param aOOMMode to enable/disable the OOM environment +*/ +LOCAL_C void DoOOMTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc,TBool aOOMMode) + { + TheTest.Next(aTestDesc); + + TInt err=KErrNone; + TInt tryCount = 0; + do + { + __UHEAP_MARK; + //Clear any files in the persist directory + CleanupCDriveL(); + + //Initializing the server resources + TServerResources::InitialiseL(); + CleanupStack::PushL(TCleanupItem(CloseTServerResources, 0)); + + CenrepSrvOOMTest* theTest=CenrepSrvOOMTest::NewL(); + CleanupStack::PushL(theTest); + + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + if(aOOMMode) + { + __UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++tryCount, KBurstRate); + } + TRAP(err, (theTest->*testFuncL)()); + + if(aOOMMode) + { + __UHEAP_RESET; + } + + if(err!=KErrNoMemory) + { + TESTKErrNone(err); + } + + CleanupStack::PopAndDestroy(theTest); + + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + TEST2(startProcessHandleCount, endProcessHandleCount); + TEST2(startThreadHandleCount, endThreadHandleCount); + + //Freeing the server resources + CleanupStack::Pop(); //CleanupTServerResources + TServerResources::Close(); + __UHEAP_MARKEND; + } while(err == KErrNoMemory); + + TESTKErrNone(err); + if(aOOMMode) + { + TheTest.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount); + } + } + +// Type definition for pointer to member function. +// Used in calling the CRegistryDataTest member function for testing. +typedef void (CenrepSwiOOMTest::*ClassSwiFuncPtrL) (TBool); +/** +Wrapper function to call all OOM test functions +@param testFuncL pointer to OOM test function +@param aTestDesc test function name +@param aOOMMode to enable/disable the OOM environment +*/ +LOCAL_C void DoOOMSwiTestL(ClassSwiFuncPtrL aTestFuncL, const TDesC& aTestDesc,TBool aOOMMode, TInt aExpectedError) + { + TheTest.Next(aTestDesc); + + TInt err=KErrNone; + TInt tryCount = 0; + do + { + __UHEAP_MARK; + + CleanupCDriveL(); + //Initializing the server resources + TServerResources::InitialiseL(); + CleanupStack::PushL(TCleanupItem(CloseTServerResources, 0)); + + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + CenrepSwiOOMTest* theTest=CenrepSwiOOMTest::NewL(); + CleanupStack::PushL(theTest); + + // Set up test + (theTest->*aTestFuncL)(ETrue); + + if(aOOMMode) + { + __UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++tryCount, KBurstRate); + } + RDebug::Print(_L("tryCount = %d"),tryCount); + + TRAP(err, (theTest->*aTestFuncL)(EFalse)); + + if(aOOMMode) + { + __UHEAP_RESET; + } + + if(err!=KErrNoMemory) + { + TEST2(err, aExpectedError); + } + + CleanupStack::PopAndDestroy(theTest); + + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + TEST2(startProcessHandleCount, endProcessHandleCount); + TEST2(startThreadHandleCount, endThreadHandleCount); + + //Freeing the server resources + CleanupStack::Pop(); //CleanupTServerResources + TServerResources::Close(); + __UHEAP_MARKEND; + } while(err == KErrNoMemory); + + TEST2(err, aExpectedError); + if(aOOMMode) + { + TheTest.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount); + } + } + +#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS +void CenrepSrvOOMTest::DoHeapRepositoryContentCheckL() + { + CServerRepository* srv=iServerRepo; + //check setting and its meta + TServerSetting* setting=NULL; + + setting=srv->GetSetting(1); + TESTHEX2(setting->iKey,1); + TESTHEX2(setting->iMeta,0x80000010); + //points to global default policy here + TESTHEX2(setting->iAccessPolicy->LowKey(),KUnspecifiedKey); + TESTHEX2(setting->iAccessPolicy->HighKey(),1); + TESTHEX2(setting->iAccessPolicy->KeyMask(),1); + + setting=srv->GetSetting(2); + TESTHEX2(setting->iKey,2); + TESTHEX2(setting->iMeta,0xA0000010); + //points to global default policy here + TESTHEX2(setting->iAccessPolicy->LowKey(),KUnspecifiedKey); + TESTHEX2(setting->iAccessPolicy->HighKey(),1); + TESTHEX2(setting->iAccessPolicy->KeyMask(),1); + + setting=srv->GetSetting(3); + TESTHEX2(setting->iKey,3); + TESTHEX2(setting->iMeta,0x800000FF); + //points to global default policy here + TESTHEX2(setting->iAccessPolicy->LowKey(),KUnspecifiedKey); + TESTHEX2(setting->iAccessPolicy->HighKey(),1); + TESTHEX2(setting->iAccessPolicy->KeyMask(),1); + + setting=srv->GetSetting(4); + TESTHEX2(setting->iKey,4); + TESTHEX2(setting->iMeta,0x80000010); + TESTHEX2(setting->iAccessPolicy->LowKey(),4); + TESTHEX2(setting->iAccessPolicy->HighKey(),1); + TESTHEX2(setting->iAccessPolicy->KeyMask(),0); + + setting=srv->GetSetting(5); + TESTHEX2(setting->iKey,5); + TESTHEX2(setting->iMeta,0xC0000063); + //points to global default policy here + TESTHEX2(setting->iAccessPolicy->LowKey(),KUnspecifiedKey); + TESTHEX2(setting->iAccessPolicy->HighKey(),1); + TESTHEX2(setting->iAccessPolicy->KeyMask(),1); + + setting=srv->GetSetting(6); + TESTHEX2(setting->iKey,6); + TESTHEX2(setting->iMeta,0x90000010); + TESTHEX2(setting->iAccessPolicy->LowKey(),6); + TESTHEX2(setting->iAccessPolicy->HighKey(),1); + TESTHEX2(setting->iAccessPolicy->KeyMask(),0); + + setting=srv->GetSetting(7); + TESTHEX2(setting->iKey,7); + TESTHEX2(setting->iMeta,0x80000010); + TESTHEX2(setting->iAccessPolicy->LowKey(),7); + TESTHEX2(setting->iAccessPolicy->HighKey(),1); + TESTHEX2(setting->iAccessPolicy->KeyMask(),0); + + setting=srv->GetSetting(9); + TESTHEX2(setting->iKey,9); + TESTHEX2(setting->iMeta,0x80000010); + TESTHEX2(setting->iAccessPolicy->LowKey(),KUnspecifiedKey); + TESTHEX2(setting->iAccessPolicy->HighKey(),1); + TESTHEX2(setting->iAccessPolicy->KeyMask(),1); + + setting=srv->GetSetting(10); + TESTHEX2(setting->iKey,10); + TESTHEX2(setting->iMeta,0x80000010); + TESTHEX2(setting->iAccessPolicy->LowKey(),10); + TESTHEX2(setting->iAccessPolicy->HighKey(),1); + TESTHEX2(setting->iAccessPolicy->KeyMask(),0); + + setting=srv->GetSetting(300); + TESTHEX2(setting->iKey,300); + TESTHEX2(setting->iMeta,0x900003E7); + TESTHEX2(setting->iAccessPolicy->LowKey(),KUnspecifiedKey); + TESTHEX2(setting->iAccessPolicy->HighKey(),1); + TESTHEX2(setting->iAccessPolicy->KeyMask(),1); + } + +LOCAL_C void DoAdditionalCheckingL(TUid aReposUid) + { + TServerResources::InitialiseL(); + CleanupStack::PushL(TCleanupItem(CloseTServerResources, 0)); + + KCurrentTestUid = aReposUid; + CenrepSrvOOMTest* test=CenrepSrvOOMTest::NewL(); + CleanupStack::PushL(test); + test->DoHeapRepositoryContentCheckL(); + + CleanupStack::PopAndDestroy(); + CleanupStack::Pop(); //CloseTServerResources + + TServerResources::Close(); + } + +/** +@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4126 +@SYMTestCaseDesc Verifying that CRE generated will have the latest CRE version which is currently 3 +@SYMTestPriority High +@SYMTestActions Validating that CRE files generated with post REQ42876 code will always contain at least version 3. + The unit test will load a txt repository and then modify some settings so that it gets persisted + in the persists directory. The test then read the cre files to verify that the version persisted + is the latest which is 3. +@SYMTestExpectedResults The correct file version is returned. +@SYMREQ REQ42876 +*/ +LOCAL_C void DoPersistedVersionCheckingL() + { + TheTest.Next(_L(" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4126 Verifying CRE generated will always be version 3 ")); + TServerResources::InitialiseL(); + CleanupStack::PushL(TCleanupItem(CloseTServerResources, 0)); + + const TUid KTestUid={0xF1000702}; + KCurrentTestUid=KTestUid; + + CenrepSrvOOMTest* test=CenrepSrvOOMTest::NewL(); + CleanupStack::PushL(test); + + //persist immediately + test->iServerRepo->CommitChangesL(EPma); + + //now check the version of the CRE file + CHeapRepository* heap=CHeapRepository::NewL(KTestUid); + CleanupStack::PushL(heap); + TUint8 creVersion; + heap->CreateRepositoryFromCreFileL(TServerResources::iFs,_L("c:\\private\\10202be9\\persists\\protected\\f1000702.cre"),creVersion); +#ifdef SYMBIAN_INCLUDE_APP_CENTRIC + TEST2(creVersion,KPersistFormatSupportsPma); +#else + TEST2(creVersion,KPersistFormatSupportsIndMetaIndicator); +#endif + CleanupStack::PopAndDestroy(2,test); + CleanupStack::Pop(); //CloseTServerResources + TServerResources::Close(); + } + +/** +@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4127 +@SYMTestCaseDesc Server side OOM loading of a multiple ROFS PMA repository files +@SYMTestPriority High +@SYMTestActions - Create the server class CServerRepository and use it to load the multi ROFS PMA keyspace. + - Test are repeated for the following keyspace combination such as TXT/TXT, CRE/TXT or TXT/CRE and CRE/CRE. + - Test will also verify the resulting merged settings which includes checking + individual metadata bits and security policy bits + - Test will also be repeated for opening PMA keyspace with non-PMA keyspace in different ROFS layers. +@SYMTestExpectedResults - Server loading of the multi rofs keyspace should not fail and leak memory under OOM condition. +@SYMREQ REQ42876 +*/ +LOCAL_C void DoOOMMultiRofsTestL() + { + TheTest.Next(_L(" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4127 Centrep Server PMA MultiROFS OOM Test ")); + + const TUid KMultiRofsRepositoryUid0={0xF1000900}; + const TUid KMultiRofsRepositoryUid1={0xF1000901}; + const TUid KMultiRofsRepositoryUid2={0xF1000902}; + const TUid KMultiRofsRepositoryUid3={0xF1000903}; + const TUid KMultiRofsRepositoryUid4={0xF1000904}; + const TUid KMultiRofsRepositoryUid5={0xF1000905};//TXT1(core) - TXT0(rofs1) + const TUid KMultiRofsRepositoryUid6={0xF1000906};//TXT0(core) - TXT1(rofs1) + const TUid KMultiRofsRepositoryUid7={0xF1000907};//CRE1(core) - CRE0(rofs1) + const TUid KMultiRofsRepositoryUid8={0xF1000908};//CRE0(core) - CRE1(rofs1) + const TUid KMultiRofsRepositoryUid9={0xF1000909};//CRE1(core) - TXT0(rofs1) + const TUid KMultiRofsRepositoryUid10={0xF100090A};//CRE0(core) - TXT1(rofs1) + const TUid KMultiRofsRepositoryUid11={0xF100090B};//TXT1(core) - CRE0(rofs1) + const TUid KMultiRofsRepositoryUid12={0xF100090C};//TXT0(core) - CRE1(rofs1) + const TUid KMultiRofsRepositoryUid13={0xF100090D};//TXT1(core) - CRE1(rofs1) - TXT1(rofs2) - CRE0(rofs3) + // Note: TXT1 means the file is PMA repository with .txt format + // TXT0 means the file is non-PMA repository with .txt format + // CRE1 means the file is PMA repository with .cre format + // CRE0 means the file is non-PMA repository with .cre format + + //Testing the OOM of multi rofs processing + DoMultiRofsReposTestL(KMultiRofsRepositoryUid0, _L("Open Close OOM Multi ROFS Test 0"),KErrNone); + DoAdditionalCheckingL(KMultiRofsRepositoryUid0); + DoMultiRofsReposTestL(KMultiRofsRepositoryUid1, _L("Open Close OOM Multi ROFS Test 1"),KErrNone); + DoAdditionalCheckingL(KMultiRofsRepositoryUid1); + DoMultiRofsReposTestL(KMultiRofsRepositoryUid2, _L("Open Close OOM Multi ROFS Test 2"),KErrNone); + DoAdditionalCheckingL(KMultiRofsRepositoryUid2); + DoMultiRofsReposTestL(KMultiRofsRepositoryUid3, _L("Open Close OOM Multi ROFS Test 3"),KErrNone); + DoAdditionalCheckingL(KMultiRofsRepositoryUid3); + DoMultiRofsReposTestL(KMultiRofsRepositoryUid4, _L("Open Close OOM Multi ROFS Test 4"),KErrNone); + DoAdditionalCheckingL(KMultiRofsRepositoryUid4); + DoMultiRofsReposTestL(KMultiRofsRepositoryUid5, _L("Open Close OOM Multi ROFS Test 5"),KErrCorrupt); + DoMultiRofsReposTestL(KMultiRofsRepositoryUid6, _L("Open Close OOM Multi ROFS Test 6"),KErrCorrupt); + DoMultiRofsReposTestL(KMultiRofsRepositoryUid7, _L("Open Close OOM Multi ROFS Test 7"),KErrCorrupt); + DoMultiRofsReposTestL(KMultiRofsRepositoryUid8, _L("Open Close OOM Multi ROFS Test 8"),KErrCorrupt); + DoMultiRofsReposTestL(KMultiRofsRepositoryUid9, _L("Open Close OOM Multi ROFS Test 9"),KErrCorrupt); + DoMultiRofsReposTestL(KMultiRofsRepositoryUid10, _L("Open Close OOM Multi ROFS Test 10"),KErrCorrupt); + DoMultiRofsReposTestL(KMultiRofsRepositoryUid11, _L("Open Close OOM Multi ROFS Test 11"),KErrCorrupt); + DoMultiRofsReposTestL(KMultiRofsRepositoryUid12, _L("Open Close OOM Multi ROFS Test 12"),KErrCorrupt); + DoMultiRofsReposTestL(KMultiRofsRepositoryUid13, _L("Open Close OOM Multi ROFS Test 13"),KErrCorrupt); + + } +#endif + +/** +@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4125 +@SYMTestCaseDesc Server side OOM test on Centrep functionalities +@SYMTestPriority High +@SYMTestActions - Call Get, Set, Create, Delete, Move, Find, Notify, Reset on a repository. + - Simulate SWI install and upgrade install on a repository. + - Do the above steps on again under OOM condition. + - Open and Close repository under OOM condition. + - Verify the resulting merged settings which includes checking + individual metadata bits and security policy bits +@SYMTestExpectedResults - Server loading of the multi rofs keyspace should not fail and leak memory under OOM condition. +@SYMREQ REQ42876 +*/ +LOCAL_C void DoOOMTestsL() + { + TheTest.Next(_L(" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4125 Starting CENREPSRV OOM Test ")); + RFs fs; + User::LeaveIfError(fs.Connect()); + CleanupClosePushL(fs); + CFileMan* fm = CFileMan::NewL(fs); + CleanupStack::PushL(fm); + + //Clear any files in the persist directory + CleanupCDriveL(); + + //First Testuid=KTestRepositoryUid + KCurrentTestUid=KTestRepositoryUid; + + DoOOMTestL(&CenrepSrvOOMTest::GetL,_L("Get Basic Test"),EFalse); + DoOOMTestL(&CenrepSrvOOMTest::FindL,_L("FindL Basic Test"),EFalse); + DoOOMTestL(&CenrepSrvOOMTest::NotifyL,_L("NotifyL Basic Test"),EFalse); + DoOOMTestL(&CenrepSrvOOMTest::ResetL,_L("ResetL Basic Test"),EFalse); + DoOOMTestL(&CenrepSrvOOMTest::SetL,_L("SetL Basic Test"),EFalse); + DoOOMTestL(&CenrepSrvOOMTest::CreateL,_L("CreateL Basic Test"),EFalse); + DoOOMTestL(&CenrepSrvOOMTest::DeleteL,_L("DeleteL Basic Test"),EFalse); + DoOOMTestL(&CenrepSrvOOMTest::MoveL,_L("MoveL Basic Test"),EFalse); + + // Simulate response to SWI rom-upgrade and downgrade events + DoOOMSwiTestL(&CenrepSwiOOMTest::InstallTxtPmaL,_L("SwiUpgradeROMRev1L Basic Test"),EFalse, KErrNotSupported); + + // Simulate response to SWI new rep install/uninstall event events + DoOOMSwiTestL(&CenrepSwiOOMTest::InstallCrePmaL,_L("SwiInstallL Basic Test"),EFalse, KErrNotSupported); + + // Simulate SWI events before server startup + DoOOMNoServReposL(&StartupInstallL, _L("Startup Upgrade Basic Test"), EFalse); + + //OOM Test aOOMMode=ETrue + DoOOMNoServReposL(&OpenCloseL, _L("Open Close OOM Test"),ETrue); + + //Clear any files in the persist directory + CleanupCDriveL(); + TInt r = KillProcess(KCentralRepositoryServerName); + TEST2(r,KErrNone); + + DoOOMTestL(&CenrepSrvOOMTest::GetL,_L("Get OOM Test"),ETrue); + DoOOMTestL(&CenrepSrvOOMTest::FindL,_L("FindL OOM Test"),ETrue); + DoOOMTestL(&CenrepSrvOOMTest::NotifyL,_L("NotifyL OOM Test"),ETrue); + DoOOMTestL(&CenrepSrvOOMTest::ResetL,_L("ResetL OOM Test"),ETrue); + DoOOMTestL(&CenrepSrvOOMTest::SetL,_L("SetL OOM Test"),ETrue); + DoOOMTestL(&CenrepSrvOOMTest::CreateL,_L("CreateL OOM Test"),ETrue); + DoOOMTestL(&CenrepSrvOOMTest::DeleteL,_L("DeleteL OOM Test"),ETrue); + DoOOMTestL(&CenrepSrvOOMTest::MoveL,_L("MoveL OOM Test"),ETrue); + + //Clear any files in the persist directory + CleanupCDriveL(); + + DoOOMSwiTestL(&CenrepSwiOOMTest::InstallTxtPmaL,_L("SwiUpgradeROMRev1L OOM Test"),ETrue, KErrNotSupported); + + DoOOMSwiTestL(&CenrepSwiOOMTest::InstallCrePmaL,_L("SwiInstallL OOM Test"),ETrue, KErrNotSupported); + + DoOOMNoServReposL(&StartupInstallL, _L("Startup Upgrade OOM Test"), ETrue); + + DoPersistedVersionCheckingL(); +#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS + DoOOMMultiRofsTestL(); +#endif + + CleanupCDriveL(); + + CleanupStack::PopAndDestroy(2); // fs and fm + } + +LOCAL_C void MainL() + { + CActiveScheduler* scheduler = new(ELeave)CActiveScheduler; + CActiveScheduler::Install(scheduler); + + DoOOMTestsL(); + CleanupCDriveL(); + + delete scheduler; + } + +TInt E32Main() + { + TheTest.Title (); + TheTest.Start(_L("PMA OOM Cenrepserv Test")); + + CTrapCleanup* cleanup = CTrapCleanup::New(); + TheTest(cleanup != NULL); + + __UHEAP_MARK; + + TRAPD(err, MainL()); + TEST2(err, KErrNone); + + __UHEAP_MARKEND; + + TheTest.End (); + TheTest.Close (); + + delete cleanup; + + User::Heap().Check(); + return KErrNone; + }