// Copyright (c) 2009-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 <e32test.h>

#include <bautils.h>

#include <featmgr.h>

#include <featureuids.h>

#include <featurecontrol.h>

#include <featdiscovery.h>

#include <featurenotifier.h>

#include "../../../src/clientdll/featmgrresourcetester.h"

using namespace NFeature;

const TInt KInvalidFeatureId    = 90901671;

const TUid KInvalidFeatureUid   = {KInvalidFeatureId};

static TInt TheProcessHandleCount = 0;

static TInt TheThreadHandleCount = 0;

static TInt TheAllocatedCellsCount = 0;

#ifdef _DEBUG

static const TInt KBurstRate = 20;

#endif

enum TFeatMgrOomTestMode

    {

    EFeatMgrOomServerTestMode,

    EFeatMgrOomClientTestMode,

    };

///////////////////////////////////////////////////////////////////////////////////////

static RTest TheTest(_L("t_fmgroom"));

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

//Test macros and functions

void Check1(TInt aValue, TInt aLine)

    {

    if(!aValue)

        {

        RDebug::Print(_L("*** Expression evaluated to false. Line %d\r\n"), aLine);

        TheTest(EFalse, aLine);

        }

    }

void Check2(TInt aValue, TInt aExpected, TInt aLine)

    {

    if(aValue != aExpected)

        {

        RDebug::Print(_L("*** Expected: %d, got: %d. Line %d\r\n"), aExpected, aValue, aLine);

        TheTest(EFalse, aLine);

        }

    }

#define TEST(arg) ::Check1((arg), __LINE__)

#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)

///////////////////////////////////////////////////////////////////////////////////////

static void MarkHandles()

    {

    RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);

    }

static void MarkAllocatedCells()

    {

    TheAllocatedCellsCount = User::CountAllocCells();

    }

static void CheckAllocatedCells()

    {

    TInt allocatedCellsCount = User::CountAllocCells();

    TEST2(allocatedCellsCount, TheAllocatedCellsCount);

    }

static void CheckHandles()

    {

    TInt endProcessHandleCount;

    TInt endThreadHandleCount;

    RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

    TEST2(TheProcessHandleCount, endProcessHandleCount);

    TEST2(TheThreadHandleCount, endThreadHandleCount);

    }

static void OomPreStep(TInt aFailingAllocationNo, TFeatMgrOomTestMode aMode = EFeatMgrOomClientTestMode)

    {

    if(aMode == EFeatMgrOomClientTestMode)

        {

        MarkHandles();

        MarkAllocatedCells();

        __UHEAP_MARK;

        __UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, aFailingAllocationNo, KBurstRate);

        }

    else

        {

        TFeatMgrResourceTester::Mark();

        TFeatMgrResourceTester::SetHeapFailure(RHeap::EBurstFailNext, aFailingAllocationNo);

        }

    }

static void OomPostStep(TFeatMgrOomTestMode aMode = EFeatMgrOomClientTestMode)

    {

    if(aMode == EFeatMgrOomClientTestMode)

        {

        __UHEAP_RESET;

        __UHEAP_MARKEND;

        CheckAllocatedCells();

        CheckHandles();

        }

    else

        {

        TFeatMgrResourceTester::SetHeapFailure(RHeap::ENone, 0);

        TFeatMgrResourceTester::Check();

        }

    }

///////////////////////////////////////////////////////////////////////////////////////

/**

@SYMTestCaseID          PDS-EFM-CT-4068

@SYMTestCaseDesc        Include test case 4069 too

@SYMTestPriority        High

@SYMTestActions         

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144262

*/

void ControlOpenOomTest(TBool aUseConnect)

    {

    TInt err = KErrNoMemory;

    TInt failingAllocationNo = 0;

    RFeatureControl ctrl;

    TheTest.Printf(_L("Iteration:\r\n"));

    while(err == KErrNoMemory)

        {

        TheTest.Printf(_L(" %d"), ++failingAllocationNo);

        OomPreStep(failingAllocationNo);

        err = aUseConnect ? ctrl.Connect() : ctrl.Open();

        ctrl.Close();

        OomPostStep();

        }

    if(err != KErrNoMemory)

        {

        TEST2(err, KErrNone);   

        }

    TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

    }

/**

@SYMTestCaseID          PDS-EFM-CT-4070

@SYMTestCaseDesc        Include test case 4071-4077 too

@SYMTestPriority        High

@SYMTestActions         

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144262

*/

void ControlFeatureSupportedOomTest(TBool aUseUid, TBool aInvalidFeature, TFeatMgrOomTestMode aMode)

    {

    RFeatureControl ctrl;

    TInt err = ctrl.Open();

    TEST2(err, KErrNone);

    const TUid KFeatureUid(aInvalidFeature ? KInvalidFeatureUid : KConnectivity);

    TFeatureEntry fentry(KFeatureUid);

    err = KErrNoMemory;

    TInt failingAllocationNo = 0;

    TheTest.Printf(_L("Iteration:\r\n"));

    while(err == KErrNoMemory)

        {

        TheTest.Printf(_L(" %d"), ++failingAllocationNo);

        OomPreStep(failingAllocationNo, aMode);

        err = aUseUid ? ctrl.FeatureSupported(KFeatureUid) : ctrl.FeatureSupported(fentry);

        OomPostStep(aMode);

        }

    ctrl.Close();

    if(err != KErrNoMemory)

        {

        TEST2(err, aInvalidFeature ? KErrNotFound : KFeatureSupported);   

        }

    TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

    }

/**

@SYMTestCaseID          PDS-EFM-CT-4078

@SYMTestCaseDesc        Include test case 4079 too

@SYMTestPriority        High

@SYMTestActions         

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144262

*/

void ControlListSupportedFeaturesOomTest(TFeatMgrOomTestMode aMode)

    {

    RFeatureControl ctrl;

    TInt err = ctrl.Open();

    TEST2(err, KErrNone);

    err = KErrNoMemory;

    TInt failingAllocationNo = 0;

    TheTest.Printf(_L("Iteration:\r\n"));

    while(err == KErrNoMemory)

        {

        TheTest.Printf(_L(" %d"), ++failingAllocationNo);

        OomPreStep(failingAllocationNo, aMode);

        const TInt KGranularity = 1;

        RFeatureUidArray farray(KGranularity);

        err = ctrl.ListSupportedFeatures(farray);

        if(err != KErrNoMemory)

            {

            TEST2(err, KErrNone);

            TInt count = farray.Count();

            TheTest.Printf(_L("===Features count: %d\r\n"), count);

            TEST(count > 0);

            }

        farray.Close();

        OomPostStep(aMode);

        }

    ctrl.Close();

    TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

    }

/**

@SYMTestCaseID          PDS-EFM-CT-4080

@SYMTestCaseDesc        Include test case 4081 too

@SYMTestPriority        High

@SYMTestActions         

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144262

*/

void ControlFeaturesSupportedOomTest(TFeatMgrOomTestMode aMode)

    {

    RFeatureControl ctrl;

    TInt err = ctrl.Open();

    TEST2(err, KErrNone);

    RFeatureUidArray farray;

    err = ctrl.ListSupportedFeatures(farray);

    TEST2(err, KErrNone);

    err = KErrNoMemory;

    TInt failingAllocationNo = 0;

    TheTest.Printf(_L("Iteration:\r\n"));

    while(err == KErrNoMemory)

        {

        TheTest.Printf(_L(" %d"), ++failingAllocationNo);

        OomPreStep(failingAllocationNo, aMode);

        RFeatureArray farray2;

        err = KErrNone;

        for(TInt i=0;i<farray.Count() && err==KErrNone;++i)

            {

            err = farray2.Append(farray[i]); 

            }

        if(err == KErrNone)

            {

            err = ctrl.FeaturesSupported(farray2);

            }

        if(err != KErrNoMemory)

            {

            TEST2(err, KErrNone);

            TInt count = farray2.Count();

            TheTest.Printf(_L("===Features count: %d\r\n"), count);

            TEST(count > 0);

            }

        farray2.Close();

        OomPostStep(aMode);

        }

    farray.Close();

    ctrl.Close();

    TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

    }

/**

@SYMTestCaseID          PDS-EFM-CT-4082

@SYMTestCaseDesc        Include test case 4083 too

@SYMTestPriority        High

@SYMTestActions         

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144262

*/

void ControlAddFeatureOomTest(TFeatMgrOomTestMode aMode)

    {

    RFeatureControl ctrl;

    TInt err = ctrl.Open();

    TEST2(err, KErrNone);

    const TUid KNewFeatureUid = {0x7888ABCE}; 

    TBitFlags32 flags;

    flags.Set(EFeatureSupported);

    flags.Set(EFeatureModifiable);    

    flags.Set(EFeaturePersisted);

    TFeatureEntry fentry(KNewFeatureUid, flags, 0x0);

    err = KErrNoMemory;

    TInt failingAllocationNo = 0;

    TheTest.Printf(_L("Iteration:\r\n"));

    while(err == KErrNoMemory)

        {

        TheTest.Printf(_L(" %d"), ++failingAllocationNo);

        OomPreStep(failingAllocationNo, aMode);

        err = ctrl.AddFeature(fentry);

        OomPostStep(aMode);

        if(err == KErrNoMemory)

            {

            err = ctrl.EnableFeature(fentry.FeatureUid());

            TEST2(err, KErrNotFound);

            }

        }

    TEST2(err, KErrNone);

    err = ctrl.DeleteFeature(fentry.FeatureUid());

    TEST2(err, KErrNone);

    ctrl.Close();

    TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

    }

/**

@SYMTestCaseID          PDS-EFM-CT-4084

@SYMTestCaseDesc        Include test case 4085 too

@SYMTestPriority        High

@SYMTestActions         

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144262

*/

void ControlDeleteFeatureOomTest(TFeatMgrOomTestMode aMode)

    {

    RFeatureControl ctrl;

    TInt err = ctrl.Open();

    TEST2(err, KErrNone);

    const TUid KNewFeatureUid = {0x7888ABCE}; 

    TBitFlags32 flags;

    flags.Set(EFeatureSupported);

    flags.Set(EFeatureModifiable);

    TFeatureEntry fentry(KNewFeatureUid, flags, 0x0);

    err = ctrl.AddFeature(fentry);

    TEST2(err, KErrNone);

    err = KErrNoMemory;

    TInt failingAllocationNo = 0;

    TheTest.Printf(_L("Iteration:\r\n"));

    while(err == KErrNoMemory)

        {

        TheTest.Printf(_L(" %d"), ++failingAllocationNo);

        OomPreStep(failingAllocationNo, aMode);

        err = ctrl.DeleteFeature(fentry.FeatureUid());

        OomPostStep(aMode);

        if(err == KErrNoMemory)

            {

            err = ctrl.EnableFeature(fentry.FeatureUid());

            TEST2(err, KErrNone);

            }

        }

    TEST2(err, KErrNone);

    ctrl.Close();

    TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

    }

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

class TTestFeatureObserver : public MFeatureObserver

    {

    public: 

        virtual void HandleNotifyChange(TFeatureChangeType /*aType*/, TFeatureEntry /*aFeature*/)

            {

            }

        virtual void HandleNotifyError(TInt /*aError*/)

            {

            }

    };

/**

@SYMTestCaseID          PDS-EFM-CT-4086

@SYMTestCaseDesc        Include test case 4087 too

@SYMTestPriority        High

@SYMTestActions         

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144262

*/

void NotifierNewLOomTest(TFeatMgrOomTestMode aMode)

    {

    CActiveScheduler* scheduler = new CActiveScheduler;

    TEST(scheduler != NULL);

    CActiveScheduler::Install(scheduler);

    RFeatureControl ctrl;

    TInt err = ctrl.Open();

    TEST2(err, KErrNone);

    TTestFeatureObserver observer;

    err = KErrNoMemory;

    TInt failingAllocationNo = 0;

    TheTest.Printf(_L("Iteration:\r\n"));

    while(err == KErrNoMemory)

        {

        TheTest.Printf(_L(" %d"), ++failingAllocationNo);

        OomPreStep(failingAllocationNo, aMode);

        CFeatureNotifier* notifier = NULL;

        TRAP(err, notifier = CFeatureNotifier::NewL(observer));

        delete notifier;

        OomPostStep(aMode);

        }

    TEST2(err, KErrNone);

    ctrl.Close();

    delete scheduler;

    TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

    }

/**

@SYMTestCaseID          PDS-EFM-CT-4088

@SYMTestCaseDesc        Include test case 4089-4091 too

@SYMTestPriority        High

@SYMTestActions         

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144262

*/

void NotifierNotifyRequestOomTest(TBool aInvalidFeature, TFeatMgrOomTestMode aMode)

    {

    CActiveScheduler* scheduler = new CActiveScheduler;

    TEST(scheduler != NULL);

    CActiveScheduler::Install(scheduler);

    RFeatureControl ctrl;

    TInt err = ctrl.Open();

    TEST2(err, KErrNone);

    TTestFeatureObserver observer;

    CFeatureNotifier* notifier = NULL;

    TRAP(err, notifier = CFeatureNotifier::NewL(observer));

    TEST2(err, KErrNone);

    const TUid KFeatureUid(aInvalidFeature ? KInvalidFeatureUid : KConnectivity);

    err = KErrNoMemory;

    TInt failingAllocationNo = 0;

    TheTest.Printf(_L("Iteration:\r\n"));

    while(err == KErrNoMemory)

        {

        TheTest.Printf(_L(" %d"), ++failingAllocationNo);

        OomPreStep(failingAllocationNo, aMode);

        err = notifier->NotifyRequest(KFeatureUid);

        (void)notifier->NotifyCancelAll();

        OomPostStep(aMode);

        }

    TEST2(err, KErrNone);

    delete notifier;

    ctrl.Close();

    delete scheduler;

    TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

    }

/**

@SYMTestCaseID          PDS-EFM-CT-4092

@SYMTestCaseDesc        Include test case 4093 too

@SYMTestPriority        High

@SYMTestActions         

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144262

*/

void NotifierNotifyRequestsOomTest(TFeatMgrOomTestMode aMode)

    {

    CActiveScheduler* scheduler = new CActiveScheduler;

    TEST(scheduler != NULL);

    CActiveScheduler::Install(scheduler);

    RFeatureControl ctrl;

    TInt err = ctrl.Open();

    TEST2(err, KErrNone);

    TTestFeatureObserver observer;

    CFeatureNotifier* notifier = NULL;

    TRAP(err, notifier = CFeatureNotifier::NewL(observer));

    TEST2(err, KErrNone);

    RFeatureUidArray features;

    err = features.Append(KConnectivity);

    TEST2(err, KErrNone);

    err = features.Append(KFax);

    TEST2(err, KErrNone);

    err = features.Append(KConnectivity);

    TEST2(err, KErrNone);

    err = features.Append(KLocationManagement);

    TEST2(err, KErrNone);

    err = KErrNoMemory;

    TInt failingAllocationNo = 0;

    TheTest.Printf(_L("Iteration:\r\n"));

    while(err == KErrNoMemory)

        {

        TheTest.Printf(_L(" %d"), ++failingAllocationNo);

        OomPreStep(failingAllocationNo, aMode);

        err = notifier->NotifyRequest(features);

        (void)notifier->NotifyCancelAll();

        OomPostStep(aMode);

        }

    TEST2(err, KErrNone);

    features.Close();

    delete notifier;

    ctrl.Close();

    delete scheduler;

    TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

    }

void DoTestsL()

    {

    TheTest.Start(_L("@SYMTestCaseID:PDS-EFM-CT-4068 RFeatureControl::Connect() OOM test"));

    ControlOpenOomTest(ETrue);

    TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4069 RFeatureControl::Open() OOM test"));

    ControlOpenOomTest(EFalse);