// 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 <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_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<TUint32>(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<class T>

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<class T>

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<TKeyFilter> pSrcIdentifier(srcKeyIdentifier);

    TKeyFilter tgtKeyIdentifier = {targetPartialId, idMask};

    TPckg<TKeyFilter> 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;