// Copyright (c) 2007-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:

// Feature Control component test steps

// 

//

/**

 @file

 @internalComponent

 @test

*/

#include <featmgr/featurecontrol.h>

#include "featurecontrol_test_steps.h"

CFeatureControlConnetctionStep::CFeatureControlConnetctionStep()

   {

   SetTestStepName(KFeatureControlConnetction);

   }

TVerdict CFeatureControlConnetctionStep::doTestStepL()

   {

   RFeatureControl control;

   TInt err = control.Connect();       

   TESTDIAGNOSTICERROR(err==KErrNone,

         _L("RFeatureControl::Connect failed: error = %d"),err);

   control.Close();

   err = control.Open();       

   TESTDIAGNOSTICERROR(err==KErrNone,

         _L("RFeatureControl::Open failed: error = %d"),err);

   control.Close();

   control.Close();

   err = control.Open();       

   TESTDIAGNOSTICERROR(err==KErrNone,

         _L("RFeatureControl::Open failed after RFeatureControl::Close called twice: error = %d"),err);

   control.Close();

   return TestStepResult();

   }

CFeatureControlSingleFeatureRequestStep::CFeatureControlSingleFeatureRequestStep()

   {

   SetTestStepName(KFeatureControlSingleFeatureRequest);

   } 

TVerdict CFeatureControlSingleFeatureRequestStep::doTestStepL()

	{

	RFeatureControl control;

	TInt err = control.Open();

	TESTDIAGNOSTICERROR(err==KErrNone,

	  _L("RFeatureControl::Open failed: error = %d"),err);

	TInt supported = control.FeatureSupported( KDefaultSupportedUid );    

	TESTDIAGNOSTICERROR(supported == KFeatureSupported,

	  _L("RFeatureControl::FeatureSupported - KFeatureSupported expected for supported feature; returned value is %d"),supported);

	supported = control.FeatureSupported( KDefaultUnsupportedUid );

	TESTDIAGNOSTICERROR(supported == KFeatureUnsupported,

	  _L("RFeatureControl::FeatureSupported - KFeatureUnsupported expected for unsupported feature; returned value is %d"),supported);

	supported = control.FeatureSupported( KUninitializedUid );

	TESTDIAGNOSTICERROR(supported == KErrNotReady,

	  _L("RFeatureControl::FeatureSupported - KErrNotReady expected for uninitialized feature; returned value is %d"),supported);

	control.Close();

	return TestStepResult();

	}

CFeatureControlDataAndStatusRequestStep::CFeatureControlDataAndStatusRequestStep()

   {

   SetTestStepName(KFeatureControlDataAndStatusRequest);

   }         

CFeatureControlMultipleFeatureRequestStep::CFeatureControlMultipleFeatureRequestStep()

   {

   SetTestStepName(KFeatureControlMultipleFeatureRequest);   

   }

TVerdict CFeatureControlMultipleFeatureRequestStep::doTestStepL(  )

   {

    RFeatureControl control;

    TInt err = control.Open();

    TESTDIAGNOSTICERROR(err==KErrNone,

         _L("RFeatureControl::Open failed: error = %d"),err);

    CleanupClosePushL( control );

    RFeatureArray uids;

    TInt supported;

    CleanupClosePushL( uids );

    // Make query with empty array

    err = control.FeaturesSupported( uids );

    TESTDIAGNOSTICERROR(err == KErrArgument,

          _L("RFeatureControl::FeaturesSupported - KErrArgument expected; error = %d"),err);    

    TInt index = uids.Find( KDefaultSupportedUid );

    TESTDIAGNOSTICERROR(index == KErrNotFound,

          _L("KErrNotFound expected; returned value is %d"),index);        

    // Add one supported feature and query statuses.

    uids.AppendL( KDefaultSupportedUid );

    err = control.FeaturesSupported( uids );

    TESTDIAGNOSTICERROR(err == KErrNone,

          _L("RFeatureControl::FeaturesSupported - KErrNone expected; error = %d"),err);    

    index = uids.Find( KDefaultSupportedUid );

    TESTDIAGNOSTICERROR(index != KErrNotFound,

          _L("Feature is expected to be found; return value is %d"),index);        

    index = uids.Find( KDefaultUnsupportedUid );

    TESTDIAGNOSTICERROR(index == KErrNotFound,

          _L("KErrNotFound expected for not added feature; return value is %d"),index);        

    index = uids.Find( KUnknownUid );

    TESTDIAGNOSTICERROR(index == KErrNotFound,

          _L("KErrNotFound expected for non existing feature; return value is %d"),index);        

    // Append feature which is supposed to be non-existent and re-query statuses.

    uids.AppendL( KUnknownUid );

    err = control.FeaturesSupported( uids );

    TESTDIAGNOSTICERROR(err == KErrNone,

          _L("RFeatureControl::FeaturesSupported - KErrNone expected; error = %d"),err);    

    index = uids.Find( KUnknownUid );

    TESTDIAGNOSTICERROR(index == KErrNotFound,

          _L("KErrNotFound still expected for non existing feature; return value is %d"),index);        

    // Add one more entry and query support statuses again

    uids.AppendL( KDefaultUnsupportedUid );

    err = control.FeaturesSupported( uids );

    TESTDIAGNOSTICERROR(err == KErrNone,

          _L("RFeatureControl::FeaturesSupported - KErrNone expected; error = %d"),err);    

    index = uids.Find( KDefaultUnsupportedUid );

    TESTDIAGNOSTICERROR(index != KErrNotFound,

          _L("Feature is expected to be found; return value is %d"),index); 

    // Finally check support statuses for supported and 

    // not-supported features are as expected.

    index = uids.Find( KDefaultSupportedUid );

    TESTDIAGNOSTICERROR(index != KErrNotFound,

          _L("Feature is expected to be found; return value is %d"),index);        

    if(index != KErrNotFound)

         {    

       supported = static_cast<TInt>(uids[index].FeatureFlags().IsSet( EFeatureSupported ));

       TESTDIAGNOSTICERROR(supported == KFeatureSupported,

             _L("KFeatureSupported expected; return value is %d"),supported);            

         }

    index = uids.Find( KDefaultUnsupportedUid );

    TESTDIAGNOSTICERROR(index != KErrNotFound,

          _L("Feature is expected to be found; return value is %d"),index);            

    if(index != KErrNotFound)

        {

        supported = static_cast<TInt>(uids[index].FeatureFlags().IsSet( EFeatureSupported ));

        TESTDIAGNOSTICERROR(supported == KFeatureUnsupported,

              _L("KFeatureUnsupported expected; return value is %d"),index);                    

        }

    CleanupStack::PopAndDestroy( &uids );

    CleanupStack::PopAndDestroy( &control );

    return TestStepResult();

    }

TVerdict CFeatureControlDataAndStatusRequestStep::doTestStepL()      

    {

    RFeatureControl control;

    TInt err = control.Open();

    TESTDIAGNOSTICERROR(err==KErrNone,

          _L("RFeatureControl::Open failed: error = %d"),err);

    // Fetch status for "unknown" feature

    TInt supported = control.FeatureSupported( emptyEntry );

    TESTDIAGNOSTICERROR(supported == KErrNotFound,

          _L("RFeatureControl::FeatureSupported - KErrNotFound expected for unknown feature; returned value is %d"),supported);

    // Fetch initially set data for supported and modifiable feature

    TFeatureEntry entry( KDefaultSupportedUid );

    supported = control.FeatureSupported( entry );

    TESTDIAGNOSTICERROR(supported == KFeatureSupported,

          _L("RFeatureControl::FeatureSupported - KFeatureSupported expected for supported feature; returned value is %d"),supported);

    TESTDIAGNOSTICERROR(entry.FeatureData() == KDefaultData1,

          _L("RFeatureControl::FeatureData - KDefaultData1 expected; returned value is %x"),entry.FeatureData());    

    // Modify and refetch data for supported and modifiable feature

    err = control.SetFeature( KDefaultSupportedUid, KChangeData );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::SetFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrNone,

              _L("RFeatureControl::SetFeature - KErrNone expected; error = %d"),err);

       }

    supported = control.FeatureSupported( entry );

    TESTDIAGNOSTICERROR(supported == KFeatureSupported,

          _L("RFeatureControl::FeatureSupported - KFeatureSupported expected for supported feature; returned value is %d"),supported);

    if (iLowCap)

       {

        TESTDIAGNOSTICERROR(entry.FeatureData() == KDefaultData1,

              _L("RFeatureControl::FeatureData - KDefaultData1 expected; returned value is %x"),entry.FeatureData());    

       }

    else

       {

        TESTDIAGNOSTICERROR(entry.FeatureData() == KChangeData,

              _L("RFeatureControl::FeatureData - KChangeData expected; returned value is %x"),entry.FeatureData());    

       }

    // Try to modify unmodifiable feature

    TFeatureEntry entry2( KUnmodifiableUid );    

    err = control.SetFeature( KUnmodifiableUid, KChangeData );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::SetFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrAccessDenied,

              _L("RFeatureControl::SetFeature - KErrAccessDenied expected; error = %d"),err);    

       }

    supported = control.FeatureSupported( entry2 );

    TESTDIAGNOSTICERROR(supported == KFeatureSupported,

          _L("RFeatureControl::FeatureSupported - KFeatureSupported expected for unmodifiable feature; returned value is %d"),supported);

    TESTDIAGNOSTICERROR(entry2.FeatureData() == KDefaultData1, 

          _L("RFeatureControl::FeatureData - KDefaultData1 expected; returned value is %x"),entry2.FeatureData());    

    control.Close();

    return TestStepResult();

    }     

CFeatureControlFeatureEnablingStep::CFeatureControlFeatureEnablingStep()

   {

   SetTestStepName(KFeatureControlFeatureEnabling);

   }       

TVerdict CFeatureControlFeatureEnablingStep::doTestStepL(  )

    {

    RFeatureControl control;

    TInt err = control.Open();

    TESTDIAGNOSTICERROR(err==KErrNone,

          _L("RFeatureControl::Open failed: error = %d"),err);

    err = control.EnableFeature( KModifiableUid );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::EnableFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrNone,

              _L("RFeatureControl::EnableFeature - KErrNone expected; error = %d"),err);                    

       }

    err = control.EnableFeature( KUnmodifiableUid );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::EnableFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrAccessDenied,

              _L("RFeatureControl::EnableFeature - KErrAccessDenied expected; error = %d"),err);                        

       }

    err = control.EnableFeature( KUnknownUid );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::EnableFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrNotFound,

              _L("RFeatureControl::EnableFeature - KErrNotFound expected; error = %d"),err);                    

       }

	err = control.EnableFeature( KPersistedUid );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::EnableFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrAccessDenied,

              _L("RFeatureControl::EnableFeature - KErrAccessDenied expected; error = %d"),err);                    

       }

    control.Close();

    return TestStepResult();

    }      

CFeatureControlFeatureDisablingStep::CFeatureControlFeatureDisablingStep()

   {

   SetTestStepName(KFeatureControlFeatureDisabling);

   }       

TVerdict CFeatureControlFeatureDisablingStep::doTestStepL(  )

    {

    RFeatureControl control;

    TInt err = control.Open();

    TESTDIAGNOSTICERROR(err==KErrNone,

          _L("RFeatureControl::Open failed: error = %d"),err);

    err = control.DisableFeature( KModifiableUid );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::DisableFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrNone,

              _L("RFeatureControl::DisableFeature - KErrNone expected; error = %d"),err);                    

       }

    err = control.DisableFeature( KUnmodifiableUid );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::DisableFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrAccessDenied,

              _L("RFeatureControl::DisableFeature - KErrAccessDenied expected; error = %d"),err);                        

       }

    err = control.DisableFeature( KUnknownUid );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::DisableFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrNotFound,

              _L("RFeatureControl::DisableFeature - KErrNotFound expected; error = %d"),err);                    

       }

    control.Close();

    return TestStepResult();

    }

CFeatureControlFeatureDataSettingStep::CFeatureControlFeatureDataSettingStep()

   {

   SetTestStepName(KFeatureControlFeatureDataSetting);

   }       

TVerdict CFeatureControlFeatureDataSettingStep::doTestStepL(  )

    {

    RFeatureControl control;

    TInt err = control.Open();

    TESTDIAGNOSTICERROR(err==KErrNone,

          _L("RFeatureControl::Open failed: error = %d"),err);

    err = control.SetFeature( KDefaultSupportedUid, KDefaultData1 );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::SetFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

       TESTDIAGNOSTICERROR(err == KErrNone,       

              _L("RFeatureControl::SetFeature - KErrNone expected; error = %d"),err);       

       }

    err = control.SetFeature( KDefaultUnsupportedUid, KDefaultData1 );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::SetFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

       TESTDIAGNOSTICERROR(err == KErrNone,       

              _L("RFeatureControl::SetFeature - KErrNone expected; error = %d"),err);

       }

    err = control.SetFeature( KUnmodifiableUid, KDefaultData1 );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::SetFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrAccessDenied, 

              _L("RFeatureControl::SetFeature - KErrAccessDenied expected; error = %d"),err);

       }

    err = control.SetFeature( KUnknownUid, KDefaultData1 );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::SetFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrNotFound, 

              _L("RFeatureControl::SetFeature - KErrNotFound expected; error = %d"),err);

       }

    control.Close();

    return TestStepResult();

    }

CFeatureControlFeatureAddingStep::CFeatureControlFeatureAddingStep()

   {   

   SetTestStepName(KFeatureControlFeatureAdding);

   }

TVerdict CFeatureControlFeatureAddingStep::doTestStepL(  )     

    {

    RFeatureControl control;

    TInt err( control.Open() );

    TESTDIAGNOSTICERROR(err==KErrNone,

          _L("RFeatureControl::Open failed: error = %d"),err);

    // Try to add already existing feature.

    TBitFlags32 flags( 0 );

    flags.Set( EFeatureSupported );

    flags.Set( EFeatureModifiable );

    TFeatureEntry entry( KDefaultSupportedUid, flags, KDefaultData1 );

    err = control.AddFeature( entry );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::AddFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrAlreadyExists,

              _L("RFeatureControl::AddFeature - KErrAlreadyExists expected; error = %d"),err);

       }

    // Add new feature. If test run sequentially, feature already exists 

    TFeatureEntry entry2( KNewUid, flags, KDefaultData1 );

    err = control.AddFeature( entry2 );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::AddFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrNone || err == KErrAlreadyExists, 

              _L("RFeatureControl::AddFeature - KErrNone or KErrAlreadyExists expected; error = %d"),err);

       }

    TBitFlags32 flags1( 0 );

    flags1.Set( EFeatureUninitialized );

    flags1.Set( EFeatureModifiable );

    TFeatureEntry entry3( KNewUid1, flags1, KDefaultData1 );

    err = control.AddFeature( entry3 );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::AddFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrNone || err == KErrAlreadyExists, 

              _L("RFeatureControl::AddFeature - KErrNone or KErrAlreadyExists expected; error = %d"),err);

       }

    /*TBitFlags32 flags2( 0 );

    flags2.Set( EFeatureUninitialized );

    TFeatureEntry entry4( KNewUid3, flags2, KDefaultData1 );

    err = control.AddFeature( entry4 );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RFeatureControl::AddFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err == KErrArgument, 

              _L("RFeatureControl::AddFeature - KErrNone or KErrAlreadyExists expected; error = %d"),err);

       }*/

    control.Close();

    return TestStepResult();

    }

CFeatureControlFeatureDataAndStatusSettingStep::CFeatureControlFeatureDataAndStatusSettingStep()

   {

   SetTestStepName(KFeatureControlFeatureDataAndStatusSetting);

   }       

TVerdict CFeatureControlFeatureDataAndStatusSettingStep::doTestStepL(  )

    {

    RFeatureControl control;

    TInt err = control.Open();

    TESTDIAGNOSTICERROR(err==KErrNone,

          _L("RFeatureControl::Open failed: error = %d"),err);

    err = control.SetFeature( KModifiableUid, EFalse, KDefaultData1 );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RRFeatureControl::SetFeature - KErrPermissionDenied expected; error = %d"),err);

       }

    else

       {

        TESTDIAGNOSTICERROR(err==KErrNone,

          _L("RFeatureControl::SetFeature - KErrNone expected: error = %d"),err);

       }    

    err = control.SetFeature( KModifiableUid, ETrue, KDefaultData1  );

    if (iLowCap)

       {

       TESTDIAGNOSTICERROR(err == KErrPermissionDenied,       

              _L("RRFeatureControl::SetFeature - KErrPermissionDenied expected; error = %d"),err);