// 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 test steps to be executed with the TEF '!OOM' option

// to run the 'doTestStepL' method in low memory conditions. Required

// resources (usually an RFeatureControl object) are member variables and are

// set up/destroyed in 'doTestStepPreambleL' and 'doTestStepPostambleL'

// 

//

/**

 @file

 @internalComponent

 @test

*/

#include <featmgr/featurecontrol.h>

#include "feature_oom_test_steps.h"

//

// This test does not have a preamble or postamble.

// The constructor is in the header, only sets the test name.

//

TVerdict CFeatureOpenOOMTestStep::doTestStepL()

    {

    RFeatureControl control;

    TInt err = control.Open();       

    // Actually we expect an error, but TEF ignores it and just looks for

    // memory leaks.

    TESTDIAGNOSTICERROR(err==KErrNone,

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

    control.Close();

    return TestStepResult();

    }

TVerdict CFeatureSupportedOOMTestStep::doTestStepPreambleL()

    {

    TInt err = icontrol.Open();

    TESTDIAGNOSTICERROR(err==KErrNone,

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

    return TestStepResult();

    }

// See if we get a memory leak using 'FeatureSupported'. I doubt we'll even see

// an out of memory issue here (despite the environment).

TVerdict CFeatureSupportedOOMTestStep::doTestStepL()

    {

    TInt supported = icontrol.FeatureSupported( KDefaultSupportedUid );    

    TESTDIAGNOSTICERROR(supported == KFeatureSupported,

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

    supported = icontrol.FeatureSupported( KDefaultUnsupportedUid );

    TESTDIAGNOSTICERROR(supported == KFeatureUnsupported,

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

    supported = icontrol.FeatureSupported( KUninitializedUid );

    TESTDIAGNOSTICERROR(supported == KErrNotReady,

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

    return TestStepResult();

    }

// Close the RFeatureControl member.

TVerdict CFeatureSupportedOOMTestStep::doTestStepPostambleL()

    {

    icontrol.Close();

    return TestStepResult();

    }

// See if we get a memory leak using 'EnableFeature'. I doubt we'll even see

// an out of memory issue here (despite the environment). TEF will ignore

// errors (with the !OOM option).

TVerdict CFeatureEnableOOMTestStep::doTestStepL()

    {

    TInt err = icontrol.EnableFeature( KModifiableUid );

    TESTDIAGNOSTICERROR(err == KErrNone,

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

    err = icontrol.EnableFeature( KUnmodifiableUid );

    TESTDIAGNOSTICERROR(err == KErrAccessDenied,

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

    err = icontrol.EnableFeature( KUnknownUid );

    TESTDIAGNOSTICERROR(err == KErrNotFound,

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

    err = icontrol.EnableFeature( KPersistedUid );

    TESTDIAGNOSTICERROR(err == KErrAccessDenied,

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

    return TestStepResult();

    }

// See if we get a memory leak using 'DisableFeature'. I doubt we'll even see

// an out of memory issue here (despite the environment). TEF will ignore

// errors (with the !OOM option).

TVerdict CFeatureDisableOOMTestStep::doTestStepL()

    {

    TInt err = icontrol.DisableFeature( KModifiableUid );

    TESTDIAGNOSTICERROR(err == KErrNone,

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

    err = icontrol.DisableFeature( KUnmodifiableUid );

    TESTDIAGNOSTICERROR(err == KErrAccessDenied,

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

    err = icontrol.DisableFeature( KUnknownUid );

    TESTDIAGNOSTICERROR(err == KErrNotFound,

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

    return TestStepResult();

    }

// See if we get a memory leak using 'SetFeature'. I doubt we'll even see

// an out of memory issue here (despite the environment). TEF will ignore

// errors (with the !OOM option).

TVerdict CFeatureSetFeatureOOMTestStep::doTestStepL()

    {

    TInt err = icontrol.SetFeature( KDefaultSupportedUid, KDefaultData1 );

    TESTDIAGNOSTICERROR(err == KErrNone,       

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

    err = icontrol.SetFeature( KDefaultUnsupportedUid, KDefaultData1 );

    TESTDIAGNOSTICERROR(err == KErrNone,       

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

    err = icontrol.SetFeature( KUnmodifiableUid, KDefaultData1 );

    TESTDIAGNOSTICERROR(err == KErrAccessDenied, 

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

    err = icontrol.SetFeature( KUnknownUid, KDefaultData1 );

    TESTDIAGNOSTICERROR(err == KErrNotFound, 

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

    return TestStepResult();

    }

// See if we get a memory leak using 'AddFeature'. I doubt we'll even see

// an out of memory issue here (despite the environment). TEF will ignore

// errors (with the !OOM option).

TVerdict CFeatureAddFeatureOOMTestStep::doTestStepL()

    {

    // Try to add already existing feature.

    TBitFlags32 flags( 0 );

    flags.Set( EFeatureSupported );

    flags.Set( EFeatureModifiable );

    TFeatureEntry entry( KDefaultSupportedUid, flags, KDefaultData1 );

    TInt err = icontrol.AddFeature( entry );

    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 = icontrol.AddFeature( entry2 );

    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 = icontrol.AddFeature( entry3 );

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

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

    return TestStepResult();

    }

// See if we get a memory leak using 'DeleteFeature'. I doubt we'll even see

// an out of memory issue here (despite the environment). TEF will ignore

// errors (with the !OOM option).

TVerdict CFeatureDelFeatureOOMTestStep::doTestStepPreambleL()

    {

    CFeatureSupportedOOMTestStep::doTestStepPreambleL();

    TBitFlags32 flags1( 0 );

    flags1.Set( EFeatureUninitialized );

    flags1.Set( EFeatureModifiable );

    flags1.Set( EFeaturePersisted );

    TFeatureEntry entry4( KNewUid3, flags1, KDefaultData1 );

    // Add a feature so we can attempt to delete it later..

    TInt err = icontrol.AddFeature( entry4 );

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

       _L("CFeatureDelFeatureOOMTestStep::doTestStepPreamble - KErrNone or KErrAlreadyExists expected adding feature; error = %d"),err);

    return TestStepResult();

    }

TVerdict CFeatureDelFeatureOOMTestStep::doTestStepL()

    {

    TInt err = icontrol.DeleteFeature( KNewUid3 );

    TESTDIAGNOSTICERROR(err == KErrNone || err == KErrNotFound, 

       _L("CFeatureDelFeatureOOMTestStep::doTestStepL - KErrNone or KErrNotFound expected deleting feature; error = %d"),err);

    return TestStepResult();

    }    

// Close the RFeatureControl member. Attempt to remove the feature added in

// the preamble.

TVerdict CFeatureDelFeatureOOMTestStep::doTestStepPostambleL()

    {

    TInt err = icontrol.DeleteFeature( KNewUid3 );

    TESTDIAGNOSTICERROR(err == KErrNone || err == KErrNotFound, 

       _L("CFeatureDelFeatureOOMTestStep::doTestStepPostamble - KErrNone or KErrNotFound expected deleting feature; error = %d"),err);

    CFeatureSupportedOOMTestStep::doTestStepPostambleL();

    return TestStepResult();

    }

// See if we get a memory leak using 'ListSupportedFeatures'.

// More to likely to give an OOM failure (which we want) than the above tests,

// because we are dealing with more information.

TVerdict CListSupportedFeaturesOOM::doTestStepL()

    {

    RFeatureUidArray supportedFeatures;

    TInt err = icontrol.ListSupportedFeatures( supportedFeatures );

    TESTDIAGNOSTICERROR(err==KErrNone || err==KErrNoMemory,

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

    if (err!=KErrNoMemory)

    	{

    	//print the content of the array

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

    		}

    	//check that the supported feature is listed

    	TESTDIAGNOSTICERROR(KErrNotFound!=supportedFeatures.Find(KDefaultSupportedUid),

    			_L("RFeatureControl::ListSupportedFeatures has not found the feature that is supported: error = %d"),err);

    	supportedFeatures.Close();

    	}

    return TestStepResult();

    }