// 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:

// EFM test steps for reconciliation testing

// 

//

/**

 @file

 @internalComponent

 @test

*/

#include <featdiscovery.h>

#include <featmgr/featurecontrol.h>

#include "efm_configured_testserver.h"

#include "reconciliation_test_steps.h"

#include "efm_teststepbase.h"

CReconciliationTestStep ::CReconciliationTestStep ()

   {

   SetTestStepName(KReconciliationTest );

   }

TVerdict CReconciliationTestStep::doTestStepL()

   {

    RFeatureControl control;

    TInt err = control.Open();

    TESTDIAGNOSTICERROR(err==KErrNone,

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

    RFeatureUidArray supportedFeatures;

    err = control.ListSupportedFeatures( supportedFeatures );

    TESTDIAGNOSTICERROR(err==KErrNone,

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

    TInt count = supportedFeatures.Count();

    INFO_PRINTF2(_L("Supported features count %d"), count);

    for(TInt i = 0; i < count; i++)

        {

        INFO_PRINTF2( _L("uid 0x%08x"), supportedFeatures[i].iUid );

        }

    supportedFeatures.Close(); 

    TInt supported = control.FeatureSupported( KDefaultSupportedUid );    

    TESTDIAGNOSTICERROR(supported == KFeatureSupported,

          _L("Reconciliation test - KFeatureSupported expected for a feature defined as supported in the persisted file; returned value is %d"),supported);

    supported = control.FeatureSupported( KBlacklistedUid );

    TESTDIAGNOSTICERROR(supported == KFeatureUnsupported,

          _L("Reconciliation test - KFeatureUnsupported expected for a feature blacklisted in the Z:-drive data file; returned value is %d"),supported);

	supported = control.FeatureSupported( KModifiableUid );

    TESTDIAGNOSTICERROR(supported == KFeatureUnsupported,

          _L("Reconciliation test - KFeatureUnsupported expected for a feature disabledin in the C:-drive data file; returned value is %d"),supported);

    supported = control.FeatureSupported( KSupportedUpgradeableUid );

    TESTDIAGNOSTICERROR(supported == KFeatureSupported,

          _L("Reconciliation test - KFeatureUnsupported expected for a feature upgradeable in the Z:-drive data file; returned value is %d"),supported);

 	supported = control.FeatureSupported( KSupportedUpgradeableBlacklistedUid );

    TESTDIAGNOSTICERROR(supported == KFeatureUnsupported,

          _L("Reconciliation test - KFeatureUnsupported expected for a feature UpgradeableBlacklisted in the Z:-drive data file; returned value is %d"),supported);

 	supported = control.FeatureSupported( KSupportedUpgradeableModifiableUid );

    TESTDIAGNOSTICERROR(supported == KFeatureSupported,

          _L("Reconciliation test - KFeatureUnsupported expected for a feature UpgradeableModifiabled in the Z:-drive data file; returned value is %d"),supported);

 	supported = control.FeatureSupported( KSupportedUpgradeableModifiableUninitialisedUid );

    TESTDIAGNOSTICERROR(supported == KErrNotReady,

          _L("Reconciliation test - KFeatureUnsupported expected for a feature UpgradeableModifiableBlacklisted in the Z:-drive data file; returned value is %d"),supported);

		supported = control.FeatureSupported( KSupportedUpgradeableModifiablePersistedUid );

    TESTDIAGNOSTICERROR(supported == KFeatureSupported,

          _L("Reconciliation test - KFeatureUnsupported expected for a feature UpgradeableModifiablePersisted in the Z:-drive data file; returned value is %d"),supported);

	control.Close();

    return TestStepResult();

   }

CFeatureManagerPanicswithInvaliedFlagsetsStep::CFeatureManagerPanicswithInvaliedFlagsetsStep()

   {

   SetTestStepName(KFeatureManagerPanicswithInvaliedFlagsets);

   }       

TVerdict CFeatureManagerPanicswithInvaliedFlagsetsStep::doTestStepL()

    {

    RFeatureControl control;

    TInt err = control.Open();

	TESTDIAGNOSTICERROR(err==KErrGeneral,

          _L("RFeatureControl::Open should fail with KErrGeneral: error = %d"),err);

    control.Close();

    return TestStepResult();

    } 

CFeatureManagerInvalidFlagsetsRuntimeStep::CFeatureManagerInvalidFlagsetsRuntimeStep()

   {

   SetTestStepName(KFeatureManagerInvalidFlagsetsRuntime);

   }       

TVerdict CFeatureManagerInvalidFlagsetsRuntimeStep::doTestStepL()

    {

    RFeatureControl control;

	TInt err = control.Open();

	TESTDIAGNOSTICERROR(err==KErrNone,

          _L("RFeatureControl::Open: KErrNone error cod e expected: error = %d"),err);

    TFeatureEntry suppprted_entry(KDefaultSupportedUid);

    TInt supported = control.FeatureSupported( suppprted_entry );

    TESTDIAGNOSTICERROR(supported == KErrNotFound,

          _L("KDefaultSupportedUid feature expected to be unknown because of invalid status flag combination; the value is = %d"),supported);

    control.Close();

    return TestStepResult();

    }    

CFeatureControlDeleteStep::CFeatureControlDeleteStep()

   {

   SetTestStepName(KFeatureControlDelete);

   }       

TVerdict CFeatureControlDeleteStep::doTestStepL()

    {

    RFeatureControl control;

    TInt err = control.Open();

	TESTDIAGNOSTICERROR(err==KErrNone,

          _L("RFeatureControl::Open should return with KErrNone: error = %d"),err);

    const TUid KNewModifiableUid = { 0x00000201 };

    const TUid KNewNonModifiableUid = { 0x00000202 };

    const TUid KNewDSRUid = {0x10000001  };

    const TUid KNewDSRUid1 = {0x10000002  };

    const TUid KNonExist =  {0x00000301 };

    // Try to delete a feature which in Z drive.

    TFeatureEntry suppprted_entry(KDefaultSupportedUid);

    TInt supported = control.FeatureSupported( suppprted_entry );

    TESTDIAGNOSTICERROR(supported == KFeatureSupported,

          _L("KDefaultSupportedUid feature that is supposed to be supported is unsupported = %d"),supported);

    err = control.DeleteFeature(KDefaultSupportedUid);

	TESTDIAGNOSTICERROR( err == KErrAccessDenied,

              _L("RFeatureControl::DeleteFeature - KErrAccessDenied expected as the feature is there in the z: drive; error = %d"),err ); 

    //Try to delete modifiable feature

    TBitFlags32 flags1(0);

    flags1.Set( EFeatureModifiable );

    TFeatureEntry entry1( KNewModifiableUid, flags1, KDefaultData1 );

    err = control.AddFeature( entry1 );

    TESTDIAGNOSTICERROR(err == KErrNone, 

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

    err = control.DeleteFeature(KNewModifiableUid);

	TESTDIAGNOSTICERROR( err == KErrNone,

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

    //Try to delete non modifiable feature    

     TBitFlags32 flags2(0), flags3(0);

      flags2.Set(EFeatureSupported);

    TFeatureEntry entry2( KNewNonModifiableUid, flags2, KDefaultData1 );

    err = control.AddFeature( entry2 );

    TESTDIAGNOSTICERROR(err == KErrNone, 

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

    err = control.EnableFeature(KNewNonModifiableUid);

    TESTDIAGNOSTICERROR( err == KErrAccessDenied,

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

    err = control.DeleteFeature(KNewNonModifiableUid);

	TESTDIAGNOSTICERROR( err == KErrNone,

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

    //Try to delte non existent feature

    err = control.DeleteFeature(KNonExist);

	TESTDIAGNOSTICERROR( err == KErrNotFound,

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

    //Try to delete DSR Range feature 

    err = control.FeatureSupported(KNewDSRUid1);

    TESTDIAGNOSTICERROR( err == KFeatureSupported,

              _L("RFeatureControl::DeleteFeature - KFeatureSupported expected for a feature from DSR; error = %d"),err );    

    TFeatureEntry dsrZdrive_entry( KNewDSRUid1);

    err = control.AddFeature( dsrZdrive_entry );

	TESTDIAGNOSTICERROR( err == KErrNone,

              _L("RFeatureControl::AddFeature - KErrNone expected for a feature from DSR; error = %d"),err );    

    err = control.DeleteFeature(KNewDSRUid1);

    TESTDIAGNOSTICERROR( err == KErrNone,

              _L("RFeatureControl::DeleteFeature - KErrNone expected for a feature from DSR; error = %d"),err );    

    err = control.FeatureSupported(KNewDSRUid1);

    TESTDIAGNOSTICERROR( err == KFeatureSupported,

              _L("RFeatureControl::DeleteFeature - KFeatureSupported expected for a feature from DSR; error = %d"),err ); 

    //Try to delete DSR Range feature which is overwritten at the run time.

    TBitFlags32 flags4( 0 );

    flags3.Set( EFeatureSupported );

    flags3.Set( EFeatureModifiable );

	TFeatureEntry dsr_entry( KNewDSRUid, flags3, KDefaultData1 );

	err = control.AddFeature( dsr_entry );

	TESTDIAGNOSTICERROR( err == KErrNone,

              _L("RFeatureControl::AddFeature - KErrNone expected for a feature from DSR; error = %d"),err );    

    err = control.DisableFeature(KNewDSRUid);

	TESTDIAGNOSTICERROR( err == KErrNone,

              _L("RFeatureControl::DisableFeature - KErrNone expected for a feature from DSR; error = %d"),err );    

    err = control.FeatureSupported(KNewDSRUid);

    TESTDIAGNOSTICERROR( err == KFeatureUnsupported,

              _L("RFeatureControl::DeleteFeature - KFeatureSupported expected for a feature from DSR; error = %d"),err );    

    err = control.DeleteFeature(KNewDSRUid);

    TESTDIAGNOSTICERROR( err == KErrNone,

              _L("RFeatureControl::DeleteFeature - KErrNone expected for a feature from DSR; error = %d"),err );    

    err = control.FeatureSupported(KNewDSRUid);

    TESTDIAGNOSTICERROR( err == KFeatureSupported,

              _L("RFeatureControl::DeleteFeature - KFeatureSupported expected for a feature from DSR; error = %d"),err ); 

    control.Close();

    return TestStepResult();

    }