// 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 <ecamuids.hrh>

 #include <ecom/ecomresolverparams.h>

 #include "ECamPresetsTest.h"

 #include "ECamUnitTestPluginUids.hrh"

 #include "ECamUnitTestPlugin.h"

 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

 #include <ecamadvsettingsuidsconst.hrh>

 #include <ecamadvsettingsconst.h>

 #include <ecamimageprocessingconst.h>

 #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<CCamera::CCameraPresets*> (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<CCamUnitTestPlugin*>(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<CCamera::CCameraPresets*> (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<TUid> 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<TUid> 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<TUid> 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<CCamera::CCameraPresets*> (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<TUid> 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<TUid> 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<CCamUnitTestPlugin*>(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<CCamera::CCameraPresets*> (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<TUid> 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;

 	}