// 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 persistence testing
// 
//

/**
 @file
 @internalComponent
 @test
*/

#include <featmgr/featurecontrol.h>
#include "efm_teststepbase.h"
#include "persistence_test_steps.h"

CDeleteFeatStep::CDeleteFeatStep() 
	{
	SetTestStepName(KDeleteFeatureStep);
	}

TVerdict CDeleteFeatStep::doTestStepL()
	{
	// Open first session to featmgr  server
	RFeatureControl control;
	TInt err = control.Open();
	TESTDIAGNOSTICERROR(err==KErrNone,
		  _L("RFeatureControl::Open failed: error = %d"),err);

	// Adding persisted feature
	TBitFlags32 persistflags( 0 );
	persistflags.Set( EFeaturePersisted);
	TFeatureEntry persistentry( KPersistedUid, persistflags, KDefaultData1 );
	// Adding persisted feature	
	err = control.AddFeature(persistentry);
	TESTDIAGNOSTICERROR(err==KErrNone,
			   _L("Persisted feature addition failed: error = %d"),err);

	// Adding non-persisted feature
	TBitFlags32 nonpersistflags( 0 );
	nonpersistflags.Set( EFeatureModifiable);
	TFeatureEntry nonpersistentry( KNotPersistedUid, nonpersistflags, KDefaultData1 );
	// Adding non-persisted feature	
	err = control.AddFeature(nonpersistentry);
	TESTDIAGNOSTICERROR(err==KErrNone,
			   _L("Non-persisted feature addition failed: error = %d"),err);
	
	// Close the first session to featmgr
	control.Close();	
	// Wait a while until the first session closes fully before starting a new one
	User::After(2000000);

	// Opening the second session to featmgr server
	err = control.Open();
	TESTDIAGNOSTICERROR(err==KErrNone,
		  _L("RFeatureControl::Open failed: error = %d"),err);

	// Deleting persisted feature
	err = control.DeleteFeature(KPersistedUid);
	TESTDIAGNOSTICERROR(err==KErrNone,
			   _L("Persited feature deletion failed: error = %d"),err);

	// Deleting non-persisted feature
	err = control.DeleteFeature(KNotPersistedUid);
	TESTDIAGNOSTICERROR(err==KErrNotFound,
			   _L("Non-persited feature deletion failed: error = %d"),err);

	// Close the second session to featmgr server
	control.Close();
	
	return TestStepResult();	
    }

CPersistenceStoreSettingsTestStep::CPersistenceStoreSettingsTestStep()
	{
	SetTestStepName(KPersistenceStoreSettingsTest);
	}

TVerdict CPersistenceStoreSettingsTestStep::doTestStepL()
	{
	RFeatureControl control;
    TInt err = control.Open();
    TESTDIAGNOSTICERROR(err==KErrNone,
		_L("RFeatureControl::Open failed: error = %d"),err );

	//first check that the information for the supported feature is correct
	TFeatureEntry suppprted_entry(KDefaultSupportedUid);
    TInt supported = control.FeatureSupported( suppprted_entry );
    TESTDIAGNOSTIC(supported == KFeatureSupported,
          _L("KDefaultSupportedUid feature that is supposed to be supported is unsupported, test presets are broken"));
    TESTDIAGNOSTICERROR(suppprted_entry.FeatureData() == KDefaultData1,
          _L("RFeatureControl::FeatureData - Feature data is expected to be KDefaultData1 for a feature that has not been modified, returned value is = %x"),suppprted_entry.FeatureData());
	
	//change feature data
	err = control.SetFeature( KDefaultSupportedUid, KChangeData );
    TESTDIAGNOSTICERROR( err == KErrNone,
              _L("RFeatureControl::SetFeature - KErrNone expected; error = %d"),err );    
    
    //check that the information for the unsupported feature is correct
	TFeatureEntry unsuppprted_entry( KDefaultUnsupportedUid );
    supported = control.FeatureSupported( unsuppprted_entry );
    TESTDIAGNOSTIC( supported == KFeatureUnsupported,
          _L( "KDefaultUnsupportedUid feature that is supposed to be unsupported is supported, test presets are broken" ) );
    
	//change the feature state
	err = control.EnableFeature( KDefaultUnsupportedUid );
    TESTDIAGNOSTICERROR( err == KErrNone,
              _L("RFeatureControl::EnableFeature - KErrNone expected; error = %d"),err );    
	
	//check that the information for the modifiable feature is correct
	TFeatureEntry modifiable_entry( KModifiableUid );
    supported = control.FeatureSupported( modifiable_entry );
    TESTDIAGNOSTIC(supported == KFeatureSupported,
          _L("KModifiableUid feature that is supposed to be supported is unsupported, test presets are broken"));
    
	//delete modifiable feature to check that deleted features are persisted
	err = control.DeleteFeature(KModifiableUid);
	TESTDIAGNOSTICERROR( err == KErrAccessDenied,
              _L("RFeatureControl::DeleteFeature - KErrAccessDenied expected; error = %d"),err );        

    //check that the information for the not persisted feature is correct
	TFeatureEntry not_persisted_entry( KNotPersistedUid );
    supported = control.FeatureSupported( not_persisted_entry );
    TESTDIAGNOSTIC(supported == KFeatureSupported,
          _L("KNotPersistedUid feature that is supposed to be supported is unsupported, test presets are broken"));
    TESTDIAGNOSTICERROR(not_persisted_entry.FeatureData() == KDefaultData1,
            _L("RFeatureControl::FeatureData - Feature data is expected to be KDefaultData1 for a feature that has not been modified, returned value is = %x"),not_persisted_entry.FeatureData());

	//try to change the data and then disable the not persisted feature
	err = control.SetFeature( KNotPersistedUid, KChangeData );
    TESTDIAGNOSTICERROR( err == KErrNone,
              _L("RFeatureControl::SetFeature - KErrNone expected; error = %d"),err );        
	err = control.DisableFeature( KNotPersistedUid );
    TESTDIAGNOSTICERROR( err == KErrNone,
              _L("RFeatureControl::DisableFeature - KErrNone expected; error = %d"),err );
    //Build time Feature combinations
    TFeatureEntry persisted_entry( KModifiableUninitialisedPersistedUid );
    supported = control.FeatureSupported(persisted_entry );
    TESTDIAGNOSTICERROR(supported == KErrNotReady,
          _L("KModifiableUninitialisedPersistedUid  feature that is supposed to be KErrNotReady is supported, test presets are broken %"),supported);          
     
     err = control.EnableFeature( KModifiableUninitialisedPersistedUid );
	TESTDIAGNOSTICERROR( err == KErrNone,
              _L("RFeatureControl::AddFeature - KErrNone expected for a feature from supportedpersisted_entry; error = %d"),err );    
    err = control.FeatureSupported(KModifiableUninitialisedPersistedUid);
	TESTDIAGNOSTICERROR( err == KFeatureSupported,
              _L("RFeatureControl::FeatureSupported - KFeatureSupported expected for a feature from DSR; error = %d"),err );    
         
    TFeatureEntry modifiablepersisted_entry( KModifiablePersistedUid );
    supported = control.FeatureSupported(modifiablepersisted_entry );
    TESTDIAGNOSTICERROR(supported == KFeatureUnsupported,
          _L("KModifiablePersistedUid  feature that is supposed to be FeatureUnsupported is supported, test presets are broken %"),supported);          
          err = control.EnableFeature( KModifiablePersistedUid );
	TESTDIAGNOSTICERROR( err == KErrNone,
              _L("RFeatureControl::AddFeature - KErrNone expected for a feature from supportedpersisted_entry; error = %d"),err );    
    err = control.FeatureSupported(KModifiablePersistedUid);
	TESTDIAGNOSTICERROR( err == KFeatureSupported,
              _L("RFeatureControl::FeatureSupported - KFeatureSupported expected for a feature from DSR; error = %d"),err );    
              
     //Run time feature combinations 
     TBitFlags32 flags2( 0 );
    flags2.Set( EFeatureUninitialized );
    flags2.Set( EFeatureModifiable );
    flags2.Set( EFeaturePersisted );
    TFeatureEntry entry4( KNewUid3, flags2, KDefaultData1 );
    err = control.AddFeature( entry4 );
    TESTDIAGNOSTICERROR(err == KErrNone, 
             _L("RFeatureControl::AddFeature - KErrNone or KErrAlreadyExists expected; error = %d"),err);
    
    
    //check that a feature from DSR is supported
    supported = control.FeatureSupported( KDSR1Uid );
    TESTDIAGNOSTIC(supported == KFeatureSupported,
          _L("A feature from DSR is unsupported, test presets are broken"));
	
	//Add and disable the DSR feature to check that DSR features are persisted
	TBitFlags32 persistedFlags( 0 );
    persistedFlags.Set( EFeatureSupported );
	persistedFlags.Set( EFeatureModifiable );
    persistedFlags.Set( EFeaturePersisted );
    TFeatureEntry dsr_entry( KDSR1Uid, persistedFlags, 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(KDSR1Uid);
	TESTDIAGNOSTICERROR( err == KErrNone,
              _L("RFeatureControl::DisableFeature - KErrNone expected for a feature from DSR; error = %d"),err );    

    
	//add a new feature
	TFeatureEntry new_entry( KNewUid, persistedFlags, KChangeData );
    err = control.AddFeature( new_entry );
	TESTDIAGNOSTICERROR(KErrNone==err,
	         _L("Problem occured while adding a new feature: err=%d"),err);
	
	//add a new feature without the "persisted" flag
	TBitFlags32 notPersistedFlags( 0 );
	notPersistedFlags.Set( EFeatureSupported );
	notPersistedFlags.Set( EFeatureModifiable );    
    TFeatureEntry new_entry2( KNewUid2, notPersistedFlags, KChangeData );
    err = control.AddFeature( new_entry2 );
	TESTDIAGNOSTICERROR(KErrNone==err,
	         _L("Problem occured while adding a new feature: err=%d"),err);
	
	//Close the connection with the server and wait for the server to be  terminated
	control.Close();
	return TestStepResult();
	}

CPersistenceLoadSettingsTestStep::CPersistenceLoadSettingsTestStep()
	   {
	   SetTestStepName(KPersistenceLoadSettingsTest);
	   }

TVerdict CPersistenceLoadSettingsTestStep::doTestStepL()
{
	RFeatureControl control;
	//reopen the connection with the server
	TInt err = control.Open();
	TESTDIAGNOSTICERROR(err==KErrNone,
		_L("RFeatureControl::Open failed while reopening the connection: error = %d"),err);
	
	//now check that the features have been persisted
	
	//check that the changed feature data has been persisted
	TFeatureEntry supported_entry( KDefaultSupportedUid );
	TInt supported = control.FeatureSupported( supported_entry );
	TESTDIAGNOSTIC( supported == KFeatureSupported,
	      _L("KDefaultSupportedUid feature that is supposed to be supported is unsupported after the server restart") );
	TESTDIAGNOSTICERROR(supported_entry.FeatureData() == KChangeData,
	      _L("RFeatureControl::FeatureData - Feature data has not been persisted, returned value is = %x"),supported_entry.FeatureData());
	
	//check that feature state has been persisted
	TFeatureEntry unsuppprted_entry( KDefaultUnsupportedUid );
	supported = control.FeatureSupported( unsuppprted_entry );
	TESTDIAGNOSTIC( supported == KFeatureSupported,
	      _L( "KDefaultUnsupportedUid feature that is supposed to be supported is unsupported after the server restart" ) );
	      
	
	TFeatureEntry modifiableUninitialisedPersistedsupported_entry( KModifiableUninitialisedPersistedUid );
	 supported = control.FeatureSupported( modifiableUninitialisedPersistedsupported_entry );
	TESTDIAGNOSTIC( supported == KFeatureSupported,
	      _L("KModifiableUninitialisedPersistedUid feature that is supposed to be supported is unsupported after the server restart") );
	      
	TFeatureEntry modifiablePersistedsupported_entry( KModifiablePersistedUid );
	supported = control.FeatureSupported(modifiablePersistedsupported_entry );
	TESTDIAGNOSTIC( supported == KFeatureSupported,
	      _L("KModifiablePersistedUid feature that is supposed to be supported is unsupported after the server restart") );
	      
	      
	TFeatureEntry modifiableUninitialiseRuntimePersistedsupported_entry( KNewUid3 );
	supported = control.FeatureSupported(modifiableUninitialiseRuntimePersistedsupported_entry );
	TESTDIAGNOSTIC( supported == KErrNotReady,
	      _L("KNewUid3 feature that is supposed to be supported is unsupported after the server restart") );
	
	
	//check that the feature without the "persisted" flag hasn't been persisted
	TFeatureEntry not_persisted_entry( KNotPersistedUid );
	supported = control.FeatureSupported( not_persisted_entry );
	TESTDIAGNOSTIC(supported == KFeatureSupported,
	      _L("The feature without the 'persisted' flag should not be persisted"));
	TESTDIAGNOSTICERROR(not_persisted_entry.FeatureData() == KDefaultData1,
	        _L("RFeatureControl::FeatureData - Feature data for the feature without the 'persisted' flag has been persisted, returned value is = %x"),not_persisted_entry.FeatureData());	    
	
	//check that the deleted feature has been persisted
	TFeatureEntry modifiable_entry( KModifiableUid );
	supported = control.FeatureSupported( modifiable_entry );
	TESTDIAGNOSTICERROR(supported==KFeatureSupported,
	         _L("This feature Deleted feature should be reported supported as build time added features cannot be deleted, returned value is %d"),supported);
	
	//check that the feature from DSR has been persisted
	supported = control.FeatureSupported( KDSR1Uid );
	TESTDIAGNOSTICERROR(supported == KFeatureUnsupported,
	      _L("A feature from DSR has not been persisted, return value is %d"),supported );
	
	//check that added feature has been persisted
	TFeatureEntry new_entry( KNewUid );
	supported = control.FeatureSupported( new_entry );
	TESTDIAGNOSTICERROR(supported==KFeatureSupported,
	         _L("Newly added feature should be supported, returned value is %d"), supported);
	TESTDIAGNOSTICERROR(new_entry.FeatureData()==KChangeData,
			 _L("Data assigned to the added feature is expected to be KChangeData, returned value is %d"),new_entry.FeatureData());
	
	//check that added feature whithout the "persisted" flag has not been persisted
	supported = control.FeatureSupported( KNewUid2 );
	TESTDIAGNOSTICERROR(supported==KErrNotFound,
	         _L("Newly added feature without the 'persisted' flag should not be persisted, returned value is %d"), supported);
	
	control.Close();
	return TestStepResult();
}