// 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:
// t_oomcenrep.cpp
//
//
#include "t_cenrep_helper.h"
#include <e32test.h>
#include <f32file.h>
#include <utf.h>
#include "srvsess.h"
#include "sessmgr.h"
#include "srvres.h"
#include "srvreqs.h"
#include "cachemgr.h"
#include "clientrequest.h"
#include "install.h"
#include <bautils.h>
LOCAL_D RTest TheTest (_L ("t_cenrep_pma_multirofs.exe"));
///////////////////////////////////////////////////////////////////////////////////////
//Test macros and functions
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 TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
#define TESTHEX2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__, ETrue)
/////////////////////////////////////////////////////////////////////////////////////////
static void CloseTServerResources(TAny*)
{
TServerResources::Close();
}
/////////////////////////////////////////////////////////////////////////////////////////
class CenrepSrvPmaMultiRofsTest :public CBase
{
public:
CenrepSrvPmaMultiRofsTest();
~CenrepSrvPmaMultiRofsTest();
static CenrepSrvPmaMultiRofsTest* NewL(TUid aReposUid);
void DoHeapRepositoryContentCheckL();
private:
void ConstructL(TUid aReposUid);
public:
CServerRepository* iServerRepo;
CSessionNotifier* iSessionNotif;
};
//////////////////////////////////////////////////////////////////////////////////////////////////
CenrepSrvPmaMultiRofsTest::CenrepSrvPmaMultiRofsTest(){}
CenrepSrvPmaMultiRofsTest::~CenrepSrvPmaMultiRofsTest()
{
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();
}
CenrepSrvPmaMultiRofsTest* CenrepSrvPmaMultiRofsTest::NewL(TUid aReposUid)
{
CenrepSrvPmaMultiRofsTest* self=new (ELeave)CenrepSrvPmaMultiRofsTest;
CleanupStack::PushL(self);
self->ConstructL(aReposUid);
CleanupStack::Pop(self);
return self;
}
void CenrepSrvPmaMultiRofsTest::ConstructL(TUid aReposUid)
{
iServerRepo=new (ELeave)CServerRepository();
iSessionNotif=new (ELeave) CSessionNotifier();
iServerRepo->OpenL(aReposUid,*iSessionNotif);
}
//Deletes the CServerRepository object properly
LOCAL_C void ReleaseRepository(TAny* aServerRepository)
{
CServerRepository* serverRepository = static_cast<CServerRepository*>(aServerRepository);
TServerResources::iCacheManager->DisableCache();
TServerResources::iObserver->CloseiOpenRepositories();
delete serverRepository;
TServerResources::iCacheManager->EnableCache();
}
//Opening a repository and closing the repository
LOCAL_C void OpenCloseL(TUid aReposUid)
{
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(aReposUid,*sessNotif);
serverRepo->Close();
CleanupStack::PopAndDestroy(sessNotif);
CleanupStack::PopAndDestroy(1);
}
// Type definition for pointer to function
// Used for functions that can't use CenrepSrvPmaMultiRofsTest::ConstructL
/**
Wrapper function to call all test functions
@param testFuncL pointer to test function
@param aTestDesc test function name
*/
LOCAL_C void DoMultiRofsReposTestL( TUid aReposUid, const TDesC& aTestDesc, TInt aExpectedResult)
{
TheTest.Next(aTestDesc);
TInt err;
__UHEAP_MARK;
//Initializing the server resources
TServerResources::InitialiseL ();
TRAP(err, OpenCloseL(aReposUid));
TEST2(err, aExpectedResult);
//Freeing the server resources
TServerResources::Close();
__UHEAP_MARKEND;
}
void CenrepSrvPmaMultiRofsTest::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));
CenrepSrvPmaMultiRofsTest* test=CenrepSrvPmaMultiRofsTest::NewL(aReposUid);
CleanupStack::PushL(test);
test->DoHeapRepositoryContentCheckL();
CleanupStack::PopAndDestroy(); //test
CleanupStack::Pop(); //CloseTServerResources
TServerResources::Close();
}
/**
@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4124
@SYMTestCaseDesc Server side loading of a multiple ROFS PMA repository files
@SYMTestPriority High
@SYMTestActions - Create the server class CServerRepository and used 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 if the type of the keyspace is the same
- Server loading of the multi rofs keyspace should fail if the type of the keyspace is not the same
@SYMREQ REQ42876
*/
LOCAL_C void DoPMAMultiRofsTestL()
{
TheTest.Next (_L (" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4124 Centrep Server PMA MultiROFS Test"));
const TUid KMultiRofsRepositoryUid0={0xF1000900};//TXT1(core) - CRE1(rofs1) - TXT1(rofs2) - CRE1(rofs3)
const TUid KMultiRofsRepositoryUid1={0xF1000901};//TXT1(core) - TXT1(rofs1)
const TUid KMultiRofsRepositoryUid2={0xF1000902};//CRE1(core) - CRE1(rofs1)
const TUid KMultiRofsRepositoryUid3={0xF1000903};//TXT1(core) - CRE1(rofs1)
const TUid KMultiRofsRepositoryUid4={0xF1000904};//CRE1(core) - TXT1(rofs1)
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
//First Testuid=KMultiRofsRepositoryUid
//Testing the OOM of multi rofs processing
// 0xF1000900 to 0xF1000904 expect KErrNone as they are all PMA keyspaces of the same UID across
// multiple ROFS layers.
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);
// 0xF1000905 to 0xF100090D expect KErrCorrupt as they have at least mixed one PMA keyspace and one
// Non-PMA keyspace of the same UID across multiple ROFS layers.
// No need for additional checking of merged value because it should be corrupt.
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);
}
LOCAL_C void MainL()
{
CActiveScheduler* scheduler = new(ELeave)CActiveScheduler;
CActiveScheduler::Install(scheduler);
DoPMAMultiRofsTestL();
CleanupCDriveL();
delete scheduler;
}
TInt E32Main ()
{
TheTest.Title ();
TheTest.Start(_L("PMA Multi ROFS 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;
}