diff -r 000000000000 -r bde4ae8d615e os/mm/imagingandcamerafws/cameraunittest/src/TSU_ECM_ADV/ECamPresetsTest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/imagingandcamerafws/cameraunittest/src/TSU_ECM_ADV/ECamPresetsTest.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,570 @@ + +// ECamPresetsTest.cpp + +// Copyright (c) 2005-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: +// + +#include +#include +#include "ECamPresetsTest.h" +#include "ECamUnitTestPluginUids.hrh" +#include "ECamUnitTestPlugin.h" +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#include +#include +#endif +// +// RECamPresetsTest +// +RECamPresetsTest* RECamPresetsTest::NewL(TBool aAllocTest) + { + RECamPresetsTest* self = new (ELeave) RECamPresetsTest(aAllocTest); + return self; + } + +RECamPresetsTest::RECamPresetsTest(TBool /*aAllocTest*/) + { + iTestStepName = _L("MM-ECM-ADV-U-006-HP"); + } + +TVerdict RECamPresetsTest::DoTestStepL() + { + TVerdict verdict = EFail; + INFO_PRINTF1(_L("Alloc test")); + TInt i; + TInt err; + for (i = 1 ; ; i++) + { + __MM_HEAP_MARK; + + if (i % 5 == 0) + { + INFO_PRINTF2(_L("Fail count = %d"), i); + } + + __UHEAP_SETFAIL(RHeap::EFailNext, i); + + TRAP(err, verdict = DoPresetsTestStepL()); + + TAny* testAlloc = User::Alloc(1); + TBool heapTestingComplete = (testAlloc == NULL) && (err==KErrNone); + User::Free(testAlloc); + + __UHEAP_RESET; + __MM_HEAP_MARKEND; + + if ((err != KErrNoMemory ) || heapTestingComplete) + { + INFO_PRINTF4(_L("err = %d, verdict = %d, Fail count = %d"), err, verdict, i); + INFO_PRINTF1(_L("Alloc testing completed successfully")); + verdict = EPass; + break; + } + } + return verdict; + } + +TVerdict RECamPresetsTest::DoPresetsTestStepL() + { + TVerdict result = EPass; + CCamera* camera = NULL; + + TInt error = KErrNone; + CCamera::CCameraPresets* presets = NULL; + + // using observer 2 + MCameraObserver2* observer2 = NULL; + + __MM_HEAP_MARK; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + presets = static_cast (camera->CustomInterface(KECamPresetsUid)); + if (presets!= NULL) + { + CleanupStack::PushL(presets); + INFO_PRINTF1(_L("CCameraPresets object was created")); + CleanupStack::PopAndDestroy(presets); + } + else + { + result = EFail; + User::Leave(KErrNoMemory); + } + CleanupStack::PopAndDestroy(camera); + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + User::Leave(KErrNoMemory); + } + __MM_HEAP_MARKEND; + + // create a presets object using NewL + __MM_HEAP_MARK; + INFO_PRINTF1(_L("Create camera using Camera::NewL() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + TRAP(error, presets = CCamera::CCameraPresets::NewL(*camera)); + + if (error==KErrNone) + { + CleanupStack::PushL(presets); + INFO_PRINTF1(_L("CCameraPresets object was created using NewL")); + CleanupStack::PopAndDestroy(presets); + } + else + { + INFO_PRINTF1(_L("CCameraPresets object was not created using NewL")); + result = EFail; + User::Leave(KErrNoMemory); + } + CleanupStack::PopAndDestroy(camera); + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + User::Leave(KErrNoMemory); + } + __MM_HEAP_MARKEND; + + return result; + } + +// +// RECamPresetsNotificationTest +// +RECamPresetsNotificationTest* RECamPresetsNotificationTest::NewL(TBool aAllocTest) + { + RECamPresetsNotificationTest* self = new (ELeave) RECamPresetsNotificationTest(aAllocTest); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void RECamPresetsNotificationTest::ConstructL() + { + iOriginalSet.Reset(); + iResultSet.Reset(); + + } +RECamPresetsNotificationTest::RECamPresetsNotificationTest(TBool /*aAllocTest*/) + { + iTestStepName = _L("MM-ECM-ADV-U-008-HP"); + } + +TVerdict RECamPresetsNotificationTest::DoTestStepL() + { + TVerdict result = EPass; + CCamera* camera = NULL; + + TInt error = KErrNone; + CCamera::CCameraPresets* presets = NULL; + + __MM_HEAP_MARK; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*this,0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + // CCamUnitTestPlugin* camera1 = static_cast(camera); + // rely on public member, done for simplfication of an external + // initialization as it is the simplest way + // camera1->iPresets = iOriginalSet; + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + presets = static_cast (camera->CustomInterface(KECamPresetsUid)); + if (presets!= NULL) + { + CleanupStack::PushL(presets); + + // get the supported set of values + presets->GetSupportedPresetsL(iResultSet); + + //verify that the input and output are the same + INFO_PRINTF2(_L("camera supports %d presets"), iResultSet.Count()); + + // the array should not be empty + if (iResultSet.Count()==0) + { + result = EFail; + } + else + { + iResultSet.Reset(); + } + + INFO_PRINTF1(_L("Current preset shall be KUidECamPresetNone")); + TUid currentPreset = presets->Preset(); + + // Current Preset shall be KUidECamPresetNone. + if(currentPreset.iUid != KUidECamPresetNoneUidValue) + { + INFO_PRINTF1(_L("Current preset wrongly set")); + result = EFail; + } + + // set new value + iInputEventUid = KUidECamPresetBeach; + INFO_PRINTF2(_L("Select a new preset %d"), iInputEventUid.iUid); + presets->SetPreset(iInputEventUid); + + CheckNotification(iInputEventUid, result); + + presets->GetAffectedSettingsL(iResultSet); + INFO_PRINTF2(_L("This preset affected %d settings"), iResultSet.Count()); + + // get the alternative function + RArray associatedSettings; + CleanupClosePushL(associatedSettings); + associatedSettings.Reset(); + INFO_PRINTF1(_L("Get associated settings for the selected preset")); + TRAP(error,presets->GetAssociatedSettingsL(iInputEventUid, associatedSettings)); + if(error != KErrNone) + { + CleanupStack::PopAndDestroy(&associatedSettings); + } + + if (iResultSet.Count()!=associatedSettings.Count()) + { + result = EFail; + } + else + { + iResultSet.Reset(); + } + CleanupStack::PopAndDestroy(&associatedSettings); + + // set KUidECamPresetOutdoor to get range restricted settings. + iInputEventUid = KUidECamPresetOutdoor; + INFO_PRINTF2(_L("Select the Outdoor preset %d"), iInputEventUid.iUid); + presets->SetPreset(iInputEventUid); + + INFO_PRINTF1(_L("Check the RangeRestricted notification")); + CheckNotification(KUidECamEventRangeRestricted, result); + + if(result != EFail) + { + INFO_PRINTF1(_L("Retrieve the RangeRestricted settings")); + // get the range restricted settings + RArray rangeRestrictedSettings; + presets->GetRangeRestrictedSettingsL(rangeRestrictedSettings); + if (rangeRestrictedSettings.Count() == 0) + { + INFO_PRINTF1(_L("RangeRestricted settings are Zero")); + result = EFail; + } + rangeRestrictedSettings.Close(); + } + + INFO_PRINTF1(_L("Check the FeatureRestricted settings")); + // get the feature restricted settings + RArray featureRestrictedSettings; + presets->GetFeatureRestrictedSettingsL(featureRestrictedSettings); + if (featureRestrictedSettings.Count() != 0) + { + INFO_PRINTF1(_L("FeatureRestricted settings are not Zero")); + result = EFail; + } + featureRestrictedSettings.Close(); + + TBool unlockSupported = EFalse; + presets->IsPresetUnlockSupportedL(unlockSupported); + if(!unlockSupported) + { + INFO_PRINTF1(_L("Preset Unlock not supported")); + result = EFail; + } + + INFO_PRINTF1(_L("Unlock Preset")); + presets->UnlockPresetL(); + CheckNotification(KUidECamEventPresetUnlocked, result); + + INFO_PRINTF1(_L("Lock Preset")); + presets->LockPresetL(); + CheckNotification(KUidECamEventPresetLocked, result); + + CleanupStack::PopAndDestroy(presets); + } + else + { + result = EFail; + User::Leave(KErrNoMemory); + } + + CleanupStack::PopAndDestroy(camera); + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + User::Leave(KErrNoMemory); + } + + __MM_HEAP_MARKEND; + + return result; + } + +// +// RECamPresetsNegTest // +// +RECamPresetsNegTest* RECamPresetsNegTest::NewL(TBool aAllocTest) + { + RECamPresetsNegTest* self = new (ELeave) RECamPresetsNegTest(aAllocTest); + return self; + } + +RECamPresetsNegTest::RECamPresetsNegTest(TBool /*aAllocTest*/) + { + iTestStepName = _L("MM-ECM-ADV-U-0101-HP"); + } + +TVerdict RECamPresetsNegTest::DoTestStepL() + { + TVerdict result = EPass; + CCamera* camera = NULL; + + TInt error = KErrNone; + CCamera::CCameraPresets* presets = NULL; + + __MM_HEAP_MARK; + + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*this,0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + presets = static_cast (camera->CustomInterface(KECamPresetsUid)); + if (presets!= NULL) + { + CleanupStack::PushL(presets); + + TUid aCurrentPreset = presets->Preset(); + // get the current value + INFO_PRINTF2(_L("Current preset %x"), aCurrentPreset.iUid); + + // get the supported set of values + RArray aResultSet; + CleanupClosePushL(aResultSet); + aResultSet.Reset(); + presets->GetSupportedPresetsL(aResultSet); + + // Setting a non supported preset should be rejected + // In the test plugin only KUidECamPresetOutdoor, KUidECamPresetNightPartyIndoor & KUidECamPresetBeach are supported + iInputEventUid = KUidECamPresetIndoorSport; + presets->SetPreset(iInputEventUid); + + CheckNotificationNeg(iInputEventUid, result); + + // Setting a non supported preset should be rejected + // In the test plugin only KUidECamPresetOutdoor, KUidECamPresetNightPartyIndoor & KUidECamPresetBeach are supported + iInputEventUid = KUidECamPresetVideoTelephony; + presets->SetPreset(iInputEventUid); + + CheckNotificationNeg(iInputEventUid, result); + + TUid aGetPreset = presets->Preset(); + + if ((aCurrentPreset == aGetPreset) && (aGetPreset == KUidECamPresetNone)) + { + INFO_PRINTF2(_L("Current preset has not changed %x"), aGetPreset.iUid); + } + else + { + INFO_PRINTF1(_L("Expected no affected settings")); + result = EFail; + } + + // get the affected settings + RArray aAffectedSet; + CleanupClosePushL(aAffectedSet); + presets->GetAffectedSettingsL(aAffectedSet); + // the list of affected settings should be empty + if (aAffectedSet.Count()!=0) + { + INFO_PRINTF1(_L("Expected no affected settings")); + result = EFail; + } + else + { + INFO_PRINTF1(_L("No affected settings")); + } + + CleanupStack::PopAndDestroy(2, &aResultSet); //aAffectedSet + + CleanupStack::PopAndDestroy(presets); + } + else // preset is NULL + { + result = EFail; + } + CleanupStack::PopAndDestroy(camera); + } + else // error != KErrNone + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + } + __MM_HEAP_MARKEND; + + return result; + } + +// +// RECamPresetsBaselineTest +// +RECamPresetsBaselineTest* RECamPresetsBaselineTest::NewL(TBool aAllocTest) + { + RECamPresetsBaselineTest* self = new (ELeave) RECamPresetsBaselineTest(aAllocTest); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void RECamPresetsBaselineTest::ConstructL() + { + iOriginalSet.Reset(); + iResultSet.Reset(); + + } +RECamPresetsBaselineTest::RECamPresetsBaselineTest(TBool /*aAllocTest*/) + { + iTestStepName = _L("MM-ECM-ADV-U-046-HP"); + } + +TVerdict RECamPresetsBaselineTest::DoTestStepL() + { + TVerdict result = EPass; + CCamera* camera = NULL; + + TInt error = KErrNone; + CCamera::CCameraPresets* presets = NULL; + + __MM_HEAP_MARK; + INFO_PRINTF1(_L("Create camera using Camera::NewL() and MCameraObserver2")); + + TRAP(error, camera = CCamera::NewL(*this,0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + // CCamUnitTestPlugin* camera1 = static_cast(camera); + // rely on public member, done for simplfication of an external + // initialization as it is the simplest way + // camera1->iPresets = iOriginalSet; + INFO_PRINTF1(_L("KErrNone return from CCamera::NewL()")); + presets = static_cast (camera->CustomInterface(KECamPresetsUid)); + if (presets!= NULL) + { + CleanupStack::PushL(presets); + + // get the supported set of values + presets->GetSupportedPresetsL(iResultSet); + + //verify that the input and output are the same + INFO_PRINTF2(_L("camera supports %d presets"), iResultSet.Count()); + + // the array should not contain any unfamiliar uid for preset(after baseline) + for(TInt index =0; index < iResultSet.Count(); index++) + { + /** KUidECamPresetFactoryDefaultUidValue is the baseline. Any preset with greater uid value means that it has + been added in later versions */ + if(iResultSet[index].iUid > KUidECamPresetFactoryDefaultUidValue) + { + result = EFail; + } + } + + iResultSet.Reset(); + + presets->Preset(); + // set new unfamiliar value + iInputEventUid = KUidECamPresetNightPartyIndoor; + INFO_PRINTF2(_L("Select a new preset %d"), iInputEventUid.iUid); + presets->SetPreset(iInputEventUid); + + CheckNotification(iInputEventUid, result); + + if(presets->Preset().iUid != KUidECamPresetFactoryDefaultUidValue) + { + result = EFail; + } + + presets->GetAffectedSettingsL(iResultSet); + INFO_PRINTF2(_L("This preset affected %d settings"), iResultSet.Count()); + + // the array should not contain any unfamiliar uid for settings(after baseline) + for(TInt index =0; index < iResultSet.Count(); index++) + { + /** KUidECamEventCameraSettingAutoFocusType2UidValue is the baseline. Any settings with greater uid value means that it has + been added in later versions */ + if(iResultSet[index].iUid > KUidECamEventCameraSettingAutoFocusType2UidValue) + { + result = EFail; + } + } + + // get the alternative function + RArray associatedSettings; + + presets->GetAssociatedSettingsL(iInputEventUid, associatedSettings); + + if (iResultSet.Count()!=associatedSettings.Count()) + { + result = EFail; + } + else + { + iResultSet.Reset(); + } + associatedSettings.Close(); + CleanupStack::PopAndDestroy(presets); + } + else + { + result = EFail; + } + CleanupStack::PopAndDestroy(camera); + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::NewL(): observer 2"), error); + result = EFail; + } + + __MM_HEAP_MARKEND; + + return result; + }