// 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 "ECamEnhanceFuncTest.h"

#include "ECamUnitTestPluginUids.hrh"

#include "ECamUnitTestPlugin.h"

#include <ecam/ecamcommonuids.hrh>

#include <fbs.h>

/*------------------------------------------------------

 	Histogram : RECamHistTest

 *------------------------------------------------------*/

RECamHistTest* RECamHistTest::NewL(const TDesC& aTestStep)

	{

	RECamHistTest* self = new (ELeave) RECamHistTest(aTestStep);

	return self;	

	}

RECamHistTest::RECamHistTest(const TDesC& aTestStep)

	{

	iTestStepName.Copy(aTestStep);

	}

TVerdict RECamHistTest::DoTestStepL()

	{

	if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-020-HP")))

		{

		return DoTestStep_20L();

		}

	else if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-021-HP")))

		{

		return DoTestStep_21L();

		}

	else if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-022-HP")))

		{

		return DoTestStep_22L();

		}

	return EInconclusive;	

	}

TVerdict RECamHistTest::DoTestStep_20L()	

	{

	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 = DoHistTestStepL());

		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 RECamHistTest::DoHistTestStepL()

	{

	TVerdict result = EPass;

	CCamera* camera = NULL;

	TInt error = KErrNone;

	CCamera::CCameraHistogram* hist = 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()"));

		hist = 	static_cast<CCamera::CCameraHistogram*> (camera->CustomInterface(KECamHistogramUid));

	    if (hist!= NULL)

	    	{

	    	CleanupStack::PushL(hist);

	  		INFO_PRINTF1(_L("CCameraHistogram object was created")); 

	    	CleanupStack::PopAndDestroy(hist);

	    	}

	    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 Hist object using New2L

	__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()"));

		TRAP(error, hist  = CCamera::CCameraHistogram::NewL(*camera));	

		if (error==KErrNone)

	    	{

	    	CleanupStack::PushL(hist);

	  		INFO_PRINTF1(_L("CCameraHistogram object was created using NewL")); 

	    	CleanupStack::PopAndDestroy(hist);

	    	}

	    else

    		{

    		INFO_PRINTF1(_L("CCameraHistogram 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;

	}

TVerdict RECamHistTest::DoTestStep_21L()

	{

	TVerdict result = EPass;

	CCamera* camera = NULL;

	TInt error = KErrNone;

	CCamera::CCameraHistogram* hist = NULL;

	// create a Hist object using New2L

	__MM_HEAP_MARK;

	MCameraObserver2* observer2 = NULL; 

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

		TRAP(error, hist  = CCamera::CCameraHistogram::NewL(*camera));	

		if (error==KErrNone)

	    	{

	  		INFO_PRINTF1(_L("CCameraHistogram object was created using NewL")); 

	    	}

	    else

    		{

    		INFO_PRINTF1(_L("CCameraHistogram object was not created using NewL")); 

    		return EFail;

    		}	

		}

	else 

		{

		INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error);

		result = EFail;		

		}

	if (hist!= NULL)

    	{

    	CleanupStack::PushL(hist);

    	// get the supported set of values  

    	TUint32 suppformats = hist->SupportedHistograms();

    	// the array should not be empty 

        if (suppformats == 0)

        	{

        	result = EFail;

        	}

        // Preapare DSA Based Histogram	

        TUint histhandle = 0;

        TPoint orgPos(5,5);

        TSize orgSize(90,50);

        TRgb orgColor(100,100,100);

    	TRAP(error, histhandle = hist->PrepareDSAHistogramL(CCamera::CCameraHistogram::ELuminance, orgPos, orgSize, orgColor));

    	if(error==KErrNone)

    		{

    		INFO_PRINTF1(_L("DSA Histogram Created"));

    		}

    	else

    		{

    		INFO_PRINTF2(_L("DSA Histogram Created- %d"), error);

    		return EFail;

    		}

    	// set new value

    	TPoint curPos;

        TSize curSize;

        TRgb curColor;

    	TRAP(error, hist->GetDSAHistogramPropertiesL(histhandle, curPos, curSize, curColor));

    	if(error==KErrNone)

    		{

    		INFO_PRINTF1(_L("Get Histogram Properties"));

    		}

    	else

    		{

    		INFO_PRINTF2(_L("Get Histogram Properties- %d"), error);

    		return EFail;

    		}

    	if(curPos != orgPos || curSize != orgSize || curColor != orgColor)

    		{

    		INFO_PRINTF1(_L("Properties dont match"));

    		return EFail;

    		}

    	// new values for properties

    	orgPos = TPoint(10,10);

        orgSize = TSize(80,40);

        orgColor = TRgb(90,90,90);

       	// Lets try update

       	TRAP(error, hist->UpdateDSAHistogramPropertiesL(histhandle, orgPos, orgSize, orgColor));

		if(error==KErrNone)

			{

			INFO_PRINTF1(_L("Update Histogram Proporties Successfull"));

			}

    	else

    		{

    		INFO_PRINTF2(_L("Update Histogram Proporties- %d"), error);

    		return EFail;

    		}	

    	// Get and verify with new values

    	TRAP(error, hist->GetDSAHistogramPropertiesL(histhandle, curPos, curSize, curColor));

    	if(error==KErrNone)

    		{

    		INFO_PRINTF1(_L("Get Histogram Properties Successful"));

    		}

    	else

    		{

    		INFO_PRINTF2(_L("Get Histogram Properties- %d"), error);

    		return EFail;

    		}

    	if(curPos != orgPos || curSize != orgSize || curColor != orgColor)

    		{

    		INFO_PRINTF1(_L("Properties dont match"));

    		return EFail;

    		}

		TRAP(error, hist->DestroyHistogramL(histhandle));

		if(error==KErrNone)

			{

			INFO_PRINTF1(_L("Destroy Histogram Successful"));

			}

    	else

    		{

    		INFO_PRINTF2(_L("Destroy Histogram - %d"), error);

    		return EFail;

    		}

    	CleanupStack::PopAndDestroy(hist);

    	}

	CleanupStack::PopAndDestroy(camera);

	__MM_HEAP_MARKEND;

	return result;

	}

// Test step MM-ECM-ADV-U-022-HP 

TVerdict RECamHistTest::DoTestStep_22L()

	{

	TVerdict result = EPass;

	CCamera* camera = NULL;

	TInt error = KErrNone;

	CCamera::CCameraHistogram* hist = NULL;

	// create a Hist object using NewL

	__MM_HEAP_MARK;

	MCameraObserver2* observer2 = NULL; 

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

		TRAP(error, hist  = CCamera::CCameraHistogram::NewL(*camera));	

		if (error==KErrNone)

	    	{

	  		INFO_PRINTF1(_L("CCameraHistogram object was created using NewL")); 

	    	}

	    else

    		{

    		INFO_PRINTF1(_L("CCameraHistogram object was not created using NewL")); 

    		return EFail;

    		}	

		}

	else 

		{

		INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error);

		result = EFail;		

		}

	if (hist!= NULL)

    	{

    	CleanupStack::PushL(hist);

    	// get the supported set of values  

    	TUint32 suppformats = hist->SupportedHistograms();

    	// the array should not be empty 

        if (suppformats == 0)

        	{

        	result = EFail;

        	}

        // Preapare Non-DSA Based Histogram	

        TUint histhandle = 0;

        TPoint orgPos(5,5);

        TSize orgSize(90,50);

        TRgb orgColor(100,100,100);

    	TRAP(error, histhandle = hist->PrepareHistogramL(CCamera::CCameraHistogram::ELuminance));

    	if(error==KErrNone)

    		{

    		INFO_PRINTF1(_L("Non-DSA Histogram Created Successful"));

    		}

    	else

    		{

    		INFO_PRINTF2(_L("Non-DSA Histogram Created- %d"), error);

    		return EFail;

    		}

		hist->StartHistogramL(histhandle);

    	if(error==KErrNone)

    		{

    		INFO_PRINTF1(_L("Start Histogram Successful"));

    		}

    	else

    		{

    		INFO_PRINTF2(_L("Start Histogram - %d"), error);

    		return EFail;

    		}

    	// Get a list of active histograms : This has not been implemented and so the count will be 0

    	RArray<TUint> activeHistograms;

        TRAP(error, hist->GetActiveHistogramsL(activeHistograms));

        if(error==KErrNone)

			{

			INFO_PRINTF1(_L("Stop Histogram Successful"));

			}

    	else

    		{

    		INFO_PRINTF2(_L("Stop Histogram - %d"), error);

    		return EFail;

    		}

		TRAP(error, hist->StopHistogramL(histhandle));

		if(error==KErrNone)

			{

			INFO_PRINTF1(_L("Stop Histogram Successful"));

			}

    	else

    		{

    		INFO_PRINTF2(_L("Stop Histogram - %d"), error);

    		return EFail;

    		}    			

		TRAP(error, hist->DestroyHistogramL(histhandle));

		if(error==KErrNone)

			{

			INFO_PRINTF1(_L("Destroy Histogram Successful"));

			}

    	else

    		{

    		INFO_PRINTF2(_L("Destroy Histogram - %d"), error);

    		return EFail;

    		}

    	CleanupStack::PopAndDestroy(hist);

    	}

	CleanupStack::PopAndDestroy(camera);

	__MM_HEAP_MARKEND;

	return result;

	}

//

// RECamHistogramNotificationTest

//

RECamHistogramNotificationTest* RECamHistogramNotificationTest::NewL(TBool aAllocTest)

	{

	RECamHistogramNotificationTest* self = new (ELeave) RECamHistogramNotificationTest(aAllocTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;	

	}

void RECamHistogramNotificationTest::ConstructL()

	{

	iOriginalSet.Reset();

	iResultSet.Reset();

	}

RECamHistogramNotificationTest::RECamHistogramNotificationTest(TBool /*aAllocTest*/)

	{

	iTestStepName = _L("MM-ECM-ADV-U-023-HP");

	}

TVerdict RECamHistogramNotificationTest::DoTestStepL()

	{	

	TVerdict result = EPass;

	CCamera* camera = NULL;

	TInt error = KErrNone;

	CCamera::CCameraHistogram* hist = 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()"));

		TRAP(error, hist  = CCamera::CCameraHistogram::NewL(*camera));	

		if (error==KErrNone)

	    	{

	  		INFO_PRINTF1(_L("CCameraHistogram object was created using NewL")); 

	    	}

	    else

    		{

    		INFO_PRINTF1(_L("CCameraHistogram object was not created using NewL")); 

    		result = EFail;

    		}	

	    if (hist!= NULL)

	    	{

	    	CleanupStack::PushL(hist);

	    	// get the supported set of values  

	    	TUint32 suppformats = hist->SupportedHistograms();

	    	// the array should not be empty 

	        if (suppformats == 0)

	        	{

	        	result = EFail;

	        	}

	        TUint histhandle = 0;

        	TRAP(error, histhandle = hist->PrepareHistogramL(CCamera::CCameraHistogram::ELuminance));

        	// set new value

	    	iInputEventUid.iUid = KUidECamEventHistogramUidValue;

	    	hist->StartHistogramL(histhandle);

	    	if(error==KErrNone)

	    		{

	    		INFO_PRINTF1(_L("Start Histogram Successful"));

	    		}

	    	else

	    		{

	    		INFO_PRINTF2(_L("Start Histogram - %d"), error);

	    		result = EFail;

	    		}

	        CheckNotification(iInputEventUid, result);

    		// Ignore the Data - check the function

    		TRAP(error, hist->HistogramDataL());

    		if(error==KErrNone)

    			{

    			INFO_PRINTF1(_L("Histogram DataL Successful"));

    			}

	    	else

	    		{