--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/featuremgmt/featuremgr/test/tef/tef_efm_normal/src/featurecontrol_test_steps.cpp Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,672 @@
+// 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
+ TFeatureEntry emptyEntry;
+ 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);
+ }
+ else
+ {
+ TESTDIAGNOSTICERROR(err==KErrNone,
+ _L("RFeatureControl::SetFeature - KErrNone expected: error = %d"),err);
+ }
+
+ TFeatureEntry entry( KModifiableUid );
+ TInt supported = control.FeatureSupported( entry );
+ TESTDIAGNOSTICERROR(supported == KFeatureSupported,
+ _L("RFeatureControl::FeatureSupported - KFeatureSupported expected: returned value is %d"),err);
+ TESTDIAGNOSTICERROR(entry.FeatureData() == KDefaultData1,
+ _L("RFeatureControl::FeatureData - KDefaultData1 expected: returned value is %x"),entry.FeatureData());
+
+ err = control.SetFeature( KModifiableUid, ETrue, KChangeData );
+ if (iLowCap)
+ {
+ TESTDIAGNOSTICERROR(err == KErrPermissionDenied,
+ _L("RRFeatureControl::SetFeature - KErrPermissionDenied expected; error = %d"),err);
+ }
+ else
+ {
+ TESTDIAGNOSTICERROR(err==KErrNone,
+ _L("RFeatureControl::FeatureSupported - KErrNone expected: error = %d"),err);
+ }
+
+ TFeatureEntry entry2( KModifiableUid );
+ supported = control.FeatureSupported( entry2 );
+ TESTDIAGNOSTICERROR(supported == KFeatureSupported,
+ _L("RFeatureControl::FeatureSupported - KFeatureSupported expected: error = %d"),err);
+ if (iLowCap)
+ {
+ TESTDIAGNOSTICERROR(entry2.FeatureData() == KDefaultData1,
+ _L("RFeatureControl::FeatureData - KDefaultData1 expected: returned value is %x"),entry.FeatureData());
+ }
+ else
+ {
+ TESTDIAGNOSTICERROR(entry2.FeatureData() == KChangeData,
+ _L("RFeatureControl::FeatureData - KChangeData expected: returned value is %x"),entry.FeatureData());
+ }
+
+
+ err = control.SetFeature( KUnmodifiableUid, ETrue, KDefaultData1 );
+ if (iLowCap)
+ {
+ TESTDIAGNOSTICERROR(err == KErrPermissionDenied,
+ _L("RRFeatureControl::SetFeature - KErrPermissionDenied expected; error = %d"),err);
+ }
+ else
+ {
+ TESTDIAGNOSTICERROR(err==KErrAccessDenied,
+ _L("RFeatureControl::SetFeature - KErrAccessDenied expected: error = %d"),err);
+ }
+
+ err = control.SetFeature( KUnmodifiableUid, EFalse, KDefaultData1 );
+ if (iLowCap)
+ {
+ TESTDIAGNOSTICERROR(err == KErrPermissionDenied,
+ _L("RRFeatureControl::SetFeature - KErrPermissionDenied expected; error = %d"),err);
+ }
+ else
+ {
+ TESTDIAGNOSTICERROR(err==KErrAccessDenied,
+ _L("RFeatureControl::SetFeature - KErrAccessDenied expected: error = %d"),err);
+ }
+
+ err = control.SetFeature( KUnknownUid, ETrue, KDefaultData1 );
+ if (iLowCap)
+ {
+ TESTDIAGNOSTICERROR(err == KErrPermissionDenied,
+ _L("RRFeatureControl::SetFeature - KErrPermissionDenied expected; error = %d"),err);
+ }
+ else
+ {
+ TESTDIAGNOSTICERROR(err==KErrNotFound,
+ _L("RFeatureControl::SetFeature - KErrNotFound expected: error = %d"),err);
+ }
+ err = control.SetFeature( KUnknownUid, EFalse, KDefaultData1 );
+ if (iLowCap)
+ {
+ TESTDIAGNOSTICERROR(err == KErrPermissionDenied,
+ _L("RRFeatureControl::SetFeature - KErrPermissionDenied expected; error = %d"),err);
+ }
+ else
+ {
+ TESTDIAGNOSTICERROR(err==KErrNotFound,
+ _L("RFeatureControl::SetFeature - KErrNotFound expected: error = %d"),err);
+ }
+
+
+ control.Close();
+ return TestStepResult();
+ }
+
+CFeatureControlListSupportedFeaturesStep::CFeatureControlListSupportedFeaturesStep()
+ {
+ SetTestStepName(KFeatureControlListSupportedFeatures);
+ }
+
+TVerdict CFeatureControlListSupportedFeaturesStep::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);
+
+ //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();
+ control.Close();
+ return TestStepResult();
+ }
+
+CFeatureControlInvalidUsePanicTestStep::CFeatureControlInvalidUsePanicTestStep()
+ {
+ SetTestStepName(KFeatureControlInvalidUsePanicTest);
+ }
+
+TVerdict CFeatureControlInvalidUsePanicTestStep::doTestStepL()
+ {
+ SetTestStepResult(EFail);
+ RFeatureControl control;
+ //we expect a panic as a result of the following instruction as the RFeatureControl object has not been opened
+ TInt error = control.FeatureSupported(KDefaultSupportedUid);
+ ERR_PRINTF2( _L("RFeatureControl::FeatureSupported is expected to cause a panic, return value is %d"), error );
+ return TestStepResult();
+ }
+
+