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

#include <featmgr.h>

#include <featureuids.h>

#include <featurecontrol.h>

#include <featurenotifier.h>

using namespace NFeature;

const TUid KNewFeatureUid = {0x7888ABCA}; 

const TUid KNewFeatureUid2 = {0x7888ABCB}; 

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

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

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

//Deletes all created test files.

void DestroyTestEnv()

    {

    }

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

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

//Test macros and functions

void Check1(TInt aValue, TInt aLine)

    {

    if(!aValue)

        {

        DestroyTestEnv();

        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)

        {

        DestroyTestEnv();

        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__)

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

_LIT(KFeatureNoChange,          "FeatureNoChange");

_LIT(KFeatureStatusUpdated,     "FeatureStatusUpdated");

_LIT(KFeatureDataUpdated,       "FeatureDataUpdated");

_LIT(KFeatureStatusDataUpdated, "FeatureStatusDataUpdated");

_LIT(KFeatureRediscover,        "FeatureRediscover");

_LIT(KFeatureCreated,           "FeatureCreated");

_LIT(KFeatureDeleted,           "FeatureDeleted");

const TPtrC KNotificationText[] = {KFeatureNoChange(), KFeatureStatusUpdated(), KFeatureDataUpdated(), 

                                   KFeatureStatusDataUpdated(), KFeatureRediscover(), KFeatureCreated(), 

                                   KFeatureDeleted()};

class TTestFeatureObserver : public MFeatureObserver

    {

public:

    TTestFeatureObserver() :

        iType(static_cast <TFeatureChangeType> (-1)),

        iFeatureUid(KNullUid)    

        {

        }

    void SetExpected(TFeatureChangeType aType, TUid aFeatureUid)

        {

        iType = aType;

        iFeatureUid = aFeatureUid;    

        }

    void Reset()

        {

        iType = static_cast <TFeatureChangeType> (-1);

        iFeatureUid = KNullUid;    

        }

    virtual void HandleNotifyChange(TFeatureChangeType aType, TFeatureEntry aFeature)

        {

        TheTest.Printf(_L("=== HandleNotifyChange() called with aType=\"%S\" and aFeature.FeatureUid()=0x%X\r\n"), &KNotificationText[aType], aFeature.FeatureUid());

        CActiveScheduler::Stop();

        TEST2(aType, iType);

        TEST(aFeature.FeatureUid() == iFeatureUid);

        }

    virtual void HandleNotifyError(TInt aError)

        {

        TheTest.Printf(_L("=== HandleNotifyError() called with error=%d\r\n"), aError);

        CActiveScheduler::Stop();

        TEST2(aError, KErrNone);

        }

private:

        TFeatureChangeType  iType;

        TUid                iFeatureUid;    

    };

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

void AddFeature(RFeatureControl& aCtrl, TUid aFeatureUid)

    {

    TBitFlags32 flags;

    flags.ClearAll();

    flags.Set(EFeatureSupported);

    flags.Set(EFeatureModifiable);

    TFeatureEntry fentry(aFeatureUid, flags, 0x0);

    TInt err = aCtrl.AddFeature(fentry);

    TEST2(err, KErrNone);

    }

void DeleteFeature(RFeatureControl& aCtrl, TUid aFeatureUid)

    {

    TInt err = aCtrl.DeleteFeature(aFeatureUid);

    TEST2(err, KErrNone);

    }

/**

@SYMTestCaseID          PDS-FEATMGR-CT-????

@SYMTestCaseDesc        

@SYMTestPriority        High

@SYMTestActions         

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144262

*/

void NotificationsTest1()

    {

    TTestFeatureObserver observer;

    CFeatureNotifier* notifier = NULL;

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

    TEST2(err, KErrNone);

    //Request notification for feature with KNewFeatureUid uid.

    err = notifier->NotifyRequest(KNewFeatureUid);

    TEST2(err, KErrNone);

    err = notifier->NotifyRequest(KNewFeatureUid);

    TEST2(err, KErrAlreadyExists);

    RFeatureControl ctrl;

    err = ctrl.Connect();

    TEST2(err, KErrNone);

    //Add a feature with KNewFeatureUid uid and check the notification

    AddFeature(ctrl, KNewFeatureUid);

    observer.SetExpected(EFeatureFeatureCreated, KNewFeatureUid);

    CActiveScheduler::Start();

    //Set the feature status and data and check the notification

    err = ctrl.SetFeature(KNewFeatureUid, ETrue, 100);

    TEST2(err, KErrNone);

    observer.SetExpected(EFeatureStatusDataUpdated, KNewFeatureUid);

    CActiveScheduler::Start();

    //Set the feature data and check the notification

    err = ctrl.SetFeature(KNewFeatureUid, 200);

    TEST2(err, KErrNone);

    observer.SetExpected(EFeatureDataUpdated, KNewFeatureUid);

    CActiveScheduler::Start();

    //Enable the feature (it is already enabled) and check the notification

    err = ctrl.EnableFeature(KNewFeatureUid);

    TEST2(err, KErrNone);

    observer.SetExpected(EFeatureNoChange, KNewFeatureUid);//the feature is enabled - no status change

    CActiveScheduler::Start();

    //Disable the feature and check the notification

    err = ctrl.DisableFeature(KNewFeatureUid);

    TEST2(err, KErrNone);

    observer.SetExpected(EFeatureStatusUpdated, KNewFeatureUid);

    CActiveScheduler::Start();

    //Cancel notifications

    err = notifier->NotifyCancel(KNewFeatureUid);

    TEST2(err, KErrNone);

    err = notifier->NotifyCancel(KNewFeatureUid);

    TEST2(err, KErrNotFound);

    //Request notifications again    

    err = notifier->NotifyRequest(KNewFeatureUid);

    TEST2(err, KErrNone);

    //Delete the feature and check the notification

    DeleteFeature(ctrl, KNewFeatureUid);

    observer.SetExpected(EFeatureFeatureDeleted, KNewFeatureUid);

    CActiveScheduler::Start();

    //Cleanup

    ctrl.Close();

    delete notifier;

    }

/**

@SYMTestCaseID          PDS-FEATMGR-CT-????

@SYMTestCaseDesc        

@SYMTestPriority        High

@SYMTestActions         

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144262

*/

void NotificationsTest2()

    {

    TTestFeatureObserver observer;

    CFeatureNotifier* notifier = NULL;

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

    TEST2(err, KErrNone);

    RFeatureControl ctrl;

    err = ctrl.Connect();

    TEST2(err, KErrNone);

    //Add two features

    AddFeature(ctrl, KNewFeatureUid);

    AddFeature(ctrl, KNewFeatureUid2);

    //Request notifications for the added features. One of them - duplicated in the array.

    RFeatureUidArray farray;

    err = farray.Append(KNewFeatureUid);

    TEST2(err, KErrNone);

    err = farray.Append(KNewFeatureUid2);

    TEST2(err, KErrNone);

    err = farray.Append(KNewFeatureUid);

    TEST2(err, KErrNone);

    //

    err = notifier->NotifyRequest(farray);

    TEST2(err, KErrNone);

    //Enable one of the features (already enabled) and check the notification

    err = ctrl.EnableFeature(KNewFeatureUid);

    TEST2(err, KErrNone);

    observer.SetExpected(EFeatureNoChange, KNewFeatureUid);//the feature is enabled - no status change

    CActiveScheduler::Start();

    //Disable the second feature and check the notification

    err = ctrl.DisableFeature(KNewFeatureUid2);

    TEST2(err, KErrNone);

    observer.SetExpected(EFeatureStatusUpdated, KNewFeatureUid2);

    CActiveScheduler::Start();

    //Cancel notifications for the second feature

    err = notifier->NotifyCancel(KNewFeatureUid2);

    TEST2(err, KErrNone);

    //Disable the first feature and check notification

    err = ctrl.DisableFeature(KNewFeatureUid);

    TEST2(err, KErrNone);

    observer.SetExpected(EFeatureStatusUpdated, KNewFeatureUid);

    CActiveScheduler::Start();

    //Cancel all notifications

    err = notifier->NotifyCancelAll();

    TEST2(err, KErrNone);

    err = notifier->NotifyCancelAll();

    TEST2(err, KErrNone);

    //Cleanup

    farray.Close();

    ctrl.Close();

    delete notifier;

    }

void DoTestsL()

    {

    CActiveScheduler* scheduler = new CActiveScheduler;

    TEST(scheduler != NULL);

    CActiveScheduler::Install(scheduler);

    TheTest.Start(_L("@SYMTestCaseID:PDS-EFM-CT-4066 Notifications test 1"));

    NotificationsTest1();

    TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4067 Notifications test 2"));

    NotificationsTest2();

    delete scheduler;

    }

TInt E32Main()

    {

    TheTest.Title();

    CTrapCleanup* tc = CTrapCleanup::New();

    TheTest(tc != NULL);

    __UHEAP_MARK;

    TRAPD(err, DoTestsL());

    DestroyTestEnv();

    TEST2(err, KErrNone);

    __UHEAP_MARKEND;

    TheTest.End();

    TheTest.Close();

    delete tc;

    User::Heap().Check();

    return KErrNone;

    }