// 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
{
INFO_PRINTF2(_L("Histogram DataL - %d"), error);
result = EFail;
}
// Overload of HistogramDataL
TRAP(error, hist->HistogramDataL(histhandle));
if(error==KErrNone)
{
INFO_PRINTF1(_L("Histogram DataL Successful"));
}
else
{
INFO_PRINTF2(_L("Histogram DataL - %d"), error);
result = EFail;
}
TRAP(error, hist->StopHistogramL(histhandle));
if(error==KErrNone)
{
INFO_PRINTF1(_L("Stop Histogram Successful"));
}
else
{
INFO_PRINTF2(_L("Stop Histogram - %d"), error);
result = EFail;
}
TRAP(error, hist->DestroyHistogramL(histhandle));
if(error==KErrNone)
{
INFO_PRINTF1(_L("Destroy Histogram Successful"));
}
else
{
INFO_PRINTF2(_L("Destroy Histogram - %d"), error);
result = EFail;
}
CleanupStack::PopAndDestroy(hist);
}
else
{
result = EFail;
}
CleanupStack::PopAndDestroy(camera);
}
else
{
INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error);
result = EFail;
}
__MM_HEAP_MARKEND;
return result;
}
/*------------------------------------------------------
Overlay : RECamOvrlayTest
*------------------------------------------------------*/
RECamOvrlayTest* RECamOvrlayTest::NewL(const TDesC& aTestStep)
{
RECamOvrlayTest* self = new (ELeave) RECamOvrlayTest(aTestStep);
return self;
}
RECamOvrlayTest::RECamOvrlayTest(const TDesC& aTestStep)
{
iTestStepName.Copy(aTestStep);
}
TVerdict RECamOvrlayTest::DoTestStepL()
{
if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-030-HP")))
{
return DoTestStep_30L();
}
else if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-031-HP")))
{
return DoTestStep_31L();
}
return EFail;
}
TVerdict RECamOvrlayTest::DoTestStep_30L()
{
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 = DoOverlayTestStepL());
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 RECamOvrlayTest::DoOverlayTestStepL()
{
TVerdict result = EPass;
CCamera* camera = NULL;
TInt error = KErrNone;
CCamera::CCameraOverlay* ovrlay = 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()"));
ovrlay = static_cast<CCamera::CCameraOverlay*> (camera->CustomInterface(KECamOverlayUid));
if (ovrlay!= NULL)
{
CleanupStack::PushL(ovrlay);
INFO_PRINTF1(_L("CCameraOverlay object was created"));
CleanupStack::PopAndDestroy(ovrlay);
}
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 overlay object using NewL
__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, ovrlay = CCamera::CCameraOverlay::NewL(*camera));
if (error==KErrNone)
{
CleanupStack::PushL(ovrlay);
INFO_PRINTF1(_L("CCameraOverlay object was created using NewL"));
CleanupStack::PopAndDestroy(ovrlay);
}
else
{
INFO_PRINTF1(_L("CCameraOverlay 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 RECamOvrlayTest::DoTestStep_31L()
{
TVerdict result = EPass;
CCamera* camera = NULL;
TInt error = KErrNone;
CCamera::CCameraOverlay* ovrlay = NULL;
// create a Overlay object using NewL
MCameraObserver2* observer2 = NULL;
INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2"));
__MM_HEAP_MARK;
TRAP(error, camera = CCamera::New2L(*observer2, 0,0));
if (error==KErrNone)
{
CleanupStack::PushL(camera);
INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()"));
TRAP(error, ovrlay = CCamera::CCameraOverlay::NewL(*camera));
if (error==KErrNone)
{
INFO_PRINTF1(_L("CCameraOverlay object was created using NewL"));
}
else
{
INFO_PRINTF2(_L("CCameraOverlay object was not created using NewL - %d"), error);
result = EFail;
}
CleanupStack::PushL(ovrlay);
CCamera::CCameraOverlay::TOverlayParameters parameters;
parameters.iCurrentModes = CCamera::CCameraOverlay::EModeStillImage;
parameters.iCurrentTypes = CCamera::CCameraOverlay::EPerPixel;
parameters.iAlphaValue= 0;
parameters.iPosition = TPoint(2,2);
parameters.iZOrder = 1;
TInt err = RFbsSession::Connect();
if (err != KErrNone)
{
INFO_PRINTF2(_L("RFbsSession::Connect() failed, err = %d"), err);
return EInconclusive;
}
CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
CleanupStack::PushL(bitmap);
TUint ovrhandle =0;
TRAP(error, ovrhandle = ovrlay->CreateOverlayL(parameters, bitmap));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Create overlay was successful"));
}
else
{
INFO_PRINTF2(_L("Create overlay - Error - %d"), error);
result = EFail;
}
TRAP(error, ovrlay->SetOverlayBitmapL(ovrhandle, bitmap));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Set Overlay Bitmap was successful"));
}
else
{
INFO_PRINTF2(_L("Set Overlay Bitmap - Error - %d"), error);
result = EFail;
}
CFbsBitmap* modBitmap = new (ELeave) CFbsBitmap;
User::LeaveIfError(modBitmap->Create(TSize(1000,1000),EGray256));
CleanupStack::PushL(modBitmap);
TRAP(error, ovrlay->SetModifiableOverlayBitmapL(ovrhandle, modBitmap));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Set Modifiable Overlay Bitmap was successful"));
}
else
{
INFO_PRINTF2(_L("Set Modifiable Overlay Bitmap - Error - %d"), error);
result = EFail;
}
CFbsBitmap* getBitmap = new (ELeave) CFbsBitmap;
User::LeaveIfError(getBitmap->Create(TSize(1000,1000),EGray256));
CleanupStack::PushL(getBitmap);
TRAP(error, ovrlay->GetOverlayBitmapL(ovrhandle, getBitmap));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Get Overlay Bitmap was successful"));
}
else
{
INFO_PRINTF2(_L("Get Overlay Bitmap - Error - %d"), error);
result = EFail;
}
TRAP(error, ovrlay->GetOverlayParametersL(ovrhandle, parameters));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Get Overlay Parameters was successful"));
}
else
{
INFO_PRINTF2(_L("Get Overlay Parameters - Error - %d"), error);
result = EFail;
}
TRAP(error, ovrlay->SetOverlayParametersL(ovrhandle, parameters));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Set Overlay Parameters was successful"));
}
else
{
INFO_PRINTF2(_L("Set Overlay Parameters - Error - %d"), error);
result = EFail;
}
CCamera::CCameraOverlay::TOverlaySupportInfo SuppInfo;
TRAP(error, ovrlay->GetOverlaySupport(SuppInfo));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Get Overlay support was successful"));
}
else
{
INFO_PRINTF2(_L("Get Overlay support - Error - %d"), error);
result = EFail;
}
RArray<TUint> overlayHandles;
TRAP(error, ovrlay->GetAllOverlaysInZOrderL(overlayHandles));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Get All Overlays in Z order was successful"));
}
else
{
INFO_PRINTF2(_L("Get All Overlays in Z order - Error - %d"), error);
result = EFail;
}
TRAP(error, ovrlay->GetAllOverlaysInZOrderL(CCamera::CCameraOverlay::EModeStillImage,1,overlayHandles));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Get 'Mode specific' All Overlays in Z order was successful"));
}
else
{
INFO_PRINTF2(_L("Get 'Mode specific' All Overlays in Z order - Error - %d"), error);
result = EFail;
}
TRAP(error, ovrlay->SetAllOverlaysInZOrderL(overlayHandles));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Set All Overlay in Z order was successful"));
}
else
{
INFO_PRINTF2(_L("Set All Overlay in Z order- Error - %d"), error);
result = EFail;
}
TRAP(error, ovrlay->SetAllOverlaysInZOrderL(CCamera::CCameraOverlay::EModeStillImage,1,overlayHandles));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Set 'Mode specific' All Overlay in Z order was successful"));
}
else
{
INFO_PRINTF2(_L("Set 'Mode specific' All Overlay in Z order- Error - %d"), error);
result = EFail;
}
overlayHandles.Close();
TRAP(error, ovrlay->ReleaseOverlay(ovrhandle));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Release Overlay was successful"));
}
else
{
INFO_PRINTF2(_L("Release Overlay - Error - %d"), error);
result = EFail;
}
CleanupStack::PopAndDestroy(4, ovrlay); //bitmap, ovrlay
TRAP(error, ovrlay = CCamera::CCameraOverlay::NewL(*camera));
CleanupStack::PushL(ovrlay);
bitmap = new (ELeave) CFbsBitmap;
CleanupStack::PushL(bitmap);
ovrhandle =0;
TRAP(error, ovrhandle = ovrlay->CreateOverlayL(parameters, bitmap));
TSize originalSize = bitmap->SizeInPixels();
INFO_PRINTF1(_L("Test size change through CFbsbitmap"));
TSize modifiedSize(640, 480);
CFbsBitmap* modifiedBitmap = new (ELeave) CFbsBitmap;
User::LeaveIfError(modifiedBitmap->Create(modifiedSize,EColor4K));
CleanupStack::PushL(modifiedBitmap);
originalSize = modifiedBitmap->SizeInPixels();
TRAP(error, ovrlay->SetModifiableOverlayBitmapL(ovrhandle,modifiedBitmap));
CFbsBitmap* retrievedBitmap = new (ELeave) CFbsBitmap;
User::LeaveIfError(retrievedBitmap->Create(TSize(1000,1000),EGray256));
CleanupStack::PushL(retrievedBitmap);
TRAP(error, ovrlay->GetOverlayBitmapL(ovrhandle, retrievedBitmap));
TSize retrievedSize = retrievedBitmap->SizeInPixels();
if(originalSize != retrievedSize)
{
INFO_PRINTF2(_L("Modifying overlay size - Error - %d"), error);
result = EFail;
}
CleanupStack::PopAndDestroy(4, ovrlay);
}
else
{
INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error);
result = EFail;
}
RFbsSession::Disconnect();
CleanupStack::PopAndDestroy(camera);
__MM_HEAP_MARKEND;
//
__MM_HEAP_MARK;
TRAP(error, camera = CCamera::New2L(*observer2, 0,0));
if (error==KErrNone)
{
CleanupStack::PushL(camera);
INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()"));
TRAP(error, ovrlay = CCamera::CCameraOverlay::NewL(*camera));
if (error==KErrNone)
{
INFO_PRINTF1(_L("CCameraOverlay object was created using NewL"));
}
else
{
INFO_PRINTF2(_L("CCameraOverlay object was not created using NewL - %d"), error);
result = EFail;
}
CleanupStack::PushL(ovrlay);
CCamera::CCameraOverlay::TOverlayParameters parameters;
parameters.iCurrentModes = CCamera::CCameraOverlay::EModeStillImage;
parameters.iCurrentTypes = CCamera::CCameraOverlay::EPerPixel;
parameters.iAlphaValue= 0;
TSize size2(20,20);
parameters.iPosition = TPoint(2,2);
parameters.iZOrder = 1;
CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
CleanupStack::PushL(bitmap);
TUint ovrhandle =0;
TRAP(error, ovrhandle = ovrlay->CreateOverlayL(parameters, bitmap));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Create overlay was successful"));
}
else
{
INFO_PRINTF2(_L("Create overlay - Error - %d"), error);
result = EFail;
}
TRAP(error, ovrlay->GetOverlayParametersL(ovrhandle, parameters));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Get Overlay Parameters was successful"));
}
else
{
INFO_PRINTF2(_L("Get Overlay Parameters - Error - %d"), error);
result = EFail;
}
if(parameters.iCurrentModes & CCamera::CCameraOverlay::EModeStillImageContinuous)
{
INFO_PRINTF1(_L("GetOverlayParametersL was successful"));
}
else
{
INFO_PRINTF1(_L("Get Overlay Parameters unexpected result"));
result = EFail;
}
TRAP(error, ovrlay->SetOverlayParametersL(ovrhandle, parameters));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Set Overlay Parameters was successful"));
}
else
{
INFO_PRINTF2(_L("Set Overlay Parameters - Error - %d"), error);
result = EFail;
}
CCamera::CCameraOverlay::TOverlaySupportInfo SuppInfo;
TRAP(error, ovrlay->GetOverlaySupport(SuppInfo));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Get Overlay support was successful"));
}
else
{
INFO_PRINTF2(_L("Get Overlay support - Error - %d"), error);
result = EFail;
}
if(SuppInfo.iSupportedModes & CCamera::CCameraOverlay::EModeStillImageContinuous)
{
INFO_PRINTF1(_L("GetOverlaySupport values were successful"));
}
else
{
INFO_PRINTF1(_L("GetOverlaySupport values unexpected result"));
result = EFail;
}
//conditional coverage for SetOverlay Parameter
parameters.iCurrentModes = CCamera::CCameraOverlay::EModeViewfinder;
TRAP(error, ovrlay->SetOverlayParametersL(ovrhandle, parameters));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Set Overlay Parameters was successful"));
}
else
{
INFO_PRINTF2(_L("Set Overlay Parameters - Error - %d"), error);
result = EFail;
}
parameters.iCurrentModes = CCamera::CCameraOverlay::EModeNone;
TRAP(error, ovrlay->GetOverlayParametersL(ovrhandle, parameters));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Get Overlay Parameters was successful"));
}
else
{
INFO_PRINTF2(_L("Get Overlay Parameters - Error - %d"), error);
result = EFail;
}
if(parameters.iCurrentModes & CCamera::CCameraOverlay::EModeClientViewfinder)
{
INFO_PRINTF1(_L("GetOverlayParametersL was successful"));
}
else
{
INFO_PRINTF1(_L("Get Overlay Parameters unexpected result"));
result = EFail;
}
TRAP(error, ovrlay->ReleaseOverlay(ovrhandle));
if (error == KErrNone)
{
INFO_PRINTF1(_L("Release Overlay was successful"));
}
else
{
INFO_PRINTF2(_L("Release Overlay - Error - %d"), error);
result = EFail;
}
CleanupStack::PopAndDestroy(2, ovrlay); //bitmap, ovrlay
}
else
{
INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error);
result = EFail;
}
CleanupStack::PopAndDestroy(camera);
__MM_HEAP_MARKEND;
//
return result;
}
/*------------------------------------------------------
Snapshot : RECamSnapTest
*------------------------------------------------------*/
RECamSnapTest* RECamSnapTest::NewL(const TDesC& aTestStep)
{
RECamSnapTest* self = new (ELeave) RECamSnapTest(aTestStep);
return self;
}
RECamSnapTest::RECamSnapTest(const TDesC& aTestStep)
{
iTestStepName.Copy(aTestStep);
}
TVerdict RECamSnapTest::DoTestStepL()
{
if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-040-HP")))
{
return DoTestStep_40L();
}
else if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-041-HP")))
{
return DoTestStep_41L();
}
else if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-042-HP")))
{
return DoTestStep_42L();
}
return EFail;
}
TVerdict RECamSnapTest::DoTestStep_40L()
{
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 = DoSnapTestStepL());
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 RECamSnapTest::DoSnapTestStepL()
{
TVerdict result = EPass;
CCamera* camera = NULL;
TInt error = KErrNone;
CCamera::CCameraSnapshot* snap = 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()"));
snap = static_cast<CCamera::CCameraSnapshot*> (camera->CustomInterface(KECamSnapshotUid));
if (snap!= NULL)
{
CleanupStack::PushL(snap);
INFO_PRINTF1(_L("CCameraSnaphot object was created"));
CleanupStack::PopAndDestroy(snap);
}
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 Snapshot object using NewL
__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, snap = CCamera::CCameraSnapshot::NewL(*camera));
if (error==KErrNone)
{
CleanupStack::PushL(snap);
INFO_PRINTF1(_L("CCameraSnapshot object was created using NewL"));
CleanupStack::PopAndDestroy(snap);
}
else
{
INFO_PRINTF1(_L("CCameraSnapshot 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 RECamSnapTest::DoTestStep_41L()
{
TVerdict result = EPass;
CCamera* camera = NULL;
TInt error = KErrNone;
CCamera::CCameraSnapshot* snap = NULL;
// create a snapshot 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, snap = CCamera::CCameraSnapshot::NewL(*camera));
if (error==KErrNone)
{
INFO_PRINTF1(_L("CCameraSnapshot object was created using NewL"));
}
else
{
INFO_PRINTF1(_L("CCameraSnapshot object was not created using NewL"));
return EFail;
}
}
else
{
INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error);
result = EFail;
}
if (snap!= NULL)
{
CleanupStack::PushL(snap);
// get the supported formats
TUint32 suppformats = snap->SupportedFormats();
CCamera::TFormat format = CCamera::EFormatMonochrome;
TSize orgSize(90,50);
TRgb orgColor(100,100,100);
TBool AspectRatio = ETrue;
TPoint orgPos(2,2);
TRAP(error, snap->PrepareSnapshotL(format, orgPos, orgSize, orgColor,AspectRatio));
if(error==KErrNone)
{
INFO_PRINTF1(_L("Snapshot Creation Successful"));
}
else
{
INFO_PRINTF2(_L("Snapshot Creation Failed - %d"), error);
result = EFail;
}
TBool isActive = EFalse;
TRAP(error, isActive = snap->IsSnapshotActive());
if(error==KErrNone)
{
INFO_PRINTF1(_L("Is Snapshot Active Successful"));
}
else
{
INFO_PRINTF2(_L("Is Snapshot Active Failed - %d"), error);
result = EFail;
}
if(isActive)
{
INFO_PRINTF1(_L("Snapshot must not be active"));
result = EFail;
}
// Start Snapshot
TRAP(error, snap->StartSnapshot());
if(error==KErrNone)
{
INFO_PRINTF1(_L("Start Snapshot Successful"));
}
else
{
INFO_PRINTF2(_L("Start Snapshot Failed - %d"), error);
return EFail;
}
TRAP(error, isActive = snap->IsSnapshotActive());
if(error==KErrNone)
{
INFO_PRINTF1(_L("Is Snapshot Active Successful"));
}
else
{
INFO_PRINTF2(_L("Is Snapshot Active Failed - %d"), error);
result = EFail;
}
if(!isActive)
{
INFO_PRINTF1(_L("Snapshot must not be active"));
result = EFail;
}
TRAP(error, snap->StopSnapshot());
if(error==KErrNone)
{
INFO_PRINTF1(_L("Stop Snapshot Successful"));
}
else
{
INFO_PRINTF2(_L("Stop Snapshot Failed - %d"), error);
return EFail;
}
// Test new snapshot methods. They shall leave with KErrNotSupported
INFO_PRINTF1(_L("Check New Snapshot methods leave with KErrNotSupported"));
CCamera::CCameraSnapshot::TSnapshotParameters snapshotParameters;
TRAP(error, snap->PrepareSnapshotL(snapshotParameters));
if(error != KErrNotSupported)
{
INFO_PRINTF1(_L("PrepareSnapshotL unexpected result!"));
return EFail;
}
TRAP(error, snap->GetSnapshotParametersL(snapshotParameters));
if(error != KErrNotSupported)
{
INFO_PRINTF1(_L("GetSnapshotParametersL unexpected result!"));
return EFail;
}
TRAP(error, snap->SetSnapshotParametersL(snapshotParameters));
if(error != KErrNotSupported)
{
INFO_PRINTF1(_L("SetSnapshotParametersL unexpected result!"));
return EFail;
}
CCamera::CCameraSnapshot::TSnapshotState snapshotState = CCamera::CCameraSnapshot::ESnapshotInactive;
TRAP(error, snap->GetSnapshotStatusL(snapshotState));
if(error != KErrNotSupported)
{
INFO_PRINTF1(_L("GetSnapshotStatusL unexpected result!"));
return EFail;
}
CCamera::CCameraSnapshot::TSnapshotVideoFrames snapshotVideoFrames = CCamera::CCameraSnapshot::ESnapshotVideoFirstFrame;
TRAP(error, snap->SelectSnapshotVideoFramesL(snapshotVideoFrames));
if(error != KErrNotSupported)
{
INFO_PRINTF1(_L("SelectSnapshotVideoFramesL unexpected result!"));
return EFail;
}
TRAP(error, snap->EnableSnapshotL());
if(error != KErrNotSupported)
{
INFO_PRINTF1(_L("EnableSnapshotL unexpected result!"));
return EFail;
}
TRAP(error, snap->DisableSnapshotL());
if(error != KErrNotSupported)
{
INFO_PRINTF1(_L("DisableSnapshotL unexpected result!"));
return EFail;
}
CleanupStack::PopAndDestroy(snap);
}
CleanupStack::PopAndDestroy(camera);
__MM_HEAP_MARKEND;
return result;
}
TVerdict RECamSnapTest::DoTestStep_42L()
{
TVerdict result = EPass;
CCamera* camera = NULL;
TInt error = KErrNone;
CCamera::CCameraSnapshot* snap = 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, snap = CCamera::CCameraSnapshot::NewL(*camera));
if (error==KErrNone)
{
INFO_PRINTF1(_L("CCameraSnapshot object was created using NewL"));
}
else
{
INFO_PRINTF1(_L("CCameraSnapshot object was not created using NewL"));
return EFail;
}
}
else
{
INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error);
result = EFail;
}
if (snap!= NULL)
{
CleanupStack::PushL(snap);
// get the supported formats
TUint32 suppformats = snap->SupportedFormats();
CCamera::TFormat format = CCamera::EFormatMonochrome;
TSize orgSize(90,50);
TRgb orgColor(100,100,100);
TBool AspectRatio = ETrue;
TPoint orgPos(2,2);
// Test the other overload of PrepareSnapshotL
TRAP(error, snap->PrepareSnapshotL(format, orgSize, AspectRatio));
if(error==KErrNone)
{
INFO_PRINTF1(_L("Snapshot Creation Successful"));
}
else
{
INFO_PRINTF2(_L("Snapshot Creation Failed - %d"), error);
result = EFail;
}
// Set Background color Snapshot
TRAP(error, snap->SetBgColorL(orgColor));
if(error==KErrNone)
{
INFO_PRINTF1(_L("Set Background Color Successful"));
}
else
{
INFO_PRINTF2(_L("Set Background Color Failed - %d"), error);
result = EFail;
}
// Set Position
TRAP(error, snap->SetPositionL(orgPos));
if(error==KErrNone)
{
INFO_PRINTF1(_L("Set Snapshot Position Successful"));
}
else
{
INFO_PRINTF2(_L("Set Snapshot Position Failed - %d"), error);
result = EFail;
}
// Start Snapshot
TRAP(error, snap->StartSnapshot());
if(error==KErrNone)
{
INFO_PRINTF1(_L("Start Snapshot Successful"));
}
else
{
INFO_PRINTF2(_L("Start Snapshot Failed - %d"), error);
return EFail;
}
// Is shapshot active
TBool isActive = EFalse;
TRAP(error, isActive = snap->IsSnapshotActive());
if(error==KErrNone)
{
INFO_PRINTF1(_L("Is Snapshot Active Successful"));
}
else
{
INFO_PRINTF2(_L("Is Snapshot Active Failed - %d"), error);
result = EFail;
}
if(!isActive)
{
INFO_PRINTF1(_L("Snapshot must not be active"));
result = EFail;
}
// Stop Snapshot
TRAP(error, snap->StopSnapshot());
if(error==KErrNone)
{
INFO_PRINTF1(_L("Stop Snapshot Successful"));
}
else
{
INFO_PRINTF2(_L("Stop Snapshot Failed - %d"), error);
return EFail;
}
CleanupStack::PopAndDestroy(snap);
}
CleanupStack::PopAndDestroy(camera);
__MM_HEAP_MARKEND;
return result;
}
//
// RECamSnapNotificationTest
//
RECamSnapNotificationTest* RECamSnapNotificationTest::NewL(TBool aAllocTest)
{
RECamSnapNotificationTest* self = new (ELeave) RECamSnapNotificationTest(aAllocTest);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
void RECamSnapNotificationTest::ConstructL()
{
iOriginalSet.Reset();
iResultSet.Reset();
}
RECamSnapNotificationTest::RECamSnapNotificationTest(TBool /*aAllocTest*/)
{
iTestStepName = _L("MM-ECM-ADV-U-043-HP");
}
TVerdict RECamSnapNotificationTest::DoTestStepL()
{
TVerdict result = EPass;
CCamera* camera = NULL;
TInt error = KErrNone;
CCamera::CCameraSnapshot* snap = 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, snap = CCamera::CCameraSnapshot::NewL(*camera));
if (error==KErrNone)
{
INFO_PRINTF1(_L("CCameraSnapshot object was created using NewL"));
}
else
{
INFO_PRINTF1(_L("CCameraSnapshot object was not created using NewL"));
result = EFail;
}
if (snap!= NULL)
{
CleanupStack::PushL(snap);
// get the supported set of values
TUint32 suppformats = snap->SupportedFormats();
CCamera::TFormat format = CCamera::EFormatMonochrome;
TSize orgSize(90,50);
TRgb orgColor(100,100,100);
TPoint orgPos(2,2);
TBool AspectRatio = ETrue;
TRAP(error, snap->PrepareSnapshotL(format, orgPos, orgSize, orgColor,AspectRatio));
if(error==KErrNone)
{
INFO_PRINTF1(_L("Snapshot Creation Successful"));
}
else
{
INFO_PRINTF2(_L("Snapshot Creation Failed - %d"), error);
result = EFail;
}
// set new value
iInputEventUid.iUid = KUidECamEventSnapshotUidValue;
// Start Snapshot
TRAP(error, snap->StartSnapshot());
if(error==KErrNone)
{
INFO_PRINTF1(_L("Start Snapshot Successful"));
}
else
{
INFO_PRINTF2(_L("Start Snapshot Failed - %d"), error);
return EFail;
}
CheckNotification(iInputEventUid, result);
RArray<TInt> FrameIndexOrder;
// Ignore the data
TRAP(error, snap->SnapshotDataL(FrameIndexOrder));
if(error==KErrNone)
{
INFO_PRINTF1(_L("Snapshot DataL Successful"));
}
else
{
INFO_PRINTF2(_L("Snapshot DataL Failed - %d"), error);
return EFail;
}
FrameIndexOrder.Close();
TBool isActive = EFalse;
TRAP(error, isActive = snap->IsSnapshotActive());
if(error==KErrNone)
{
INFO_PRINTF1(_L("Is Snapshot Active Successful"));
}
else
{
INFO_PRINTF2(_L("Is Snapshot Active Failed - %d"), error);
return EFail;
}
if(!isActive)
{
INFO_PRINTF1(_L("Snapshot must not be active"));
result = EFail;
}
TRAP(error, snap->StopSnapshot());
if(error==KErrNone)
{
INFO_PRINTF1(_L("Stop Snapshot Successful"));
}
else
{
INFO_PRINTF2(_L("Stop Snapshot Failed - %d"), error);
return EFail;
}
CleanupStack::PopAndDestroy(snap);
}
else
{
result = EFail;
}
CleanupStack::PopAndDestroy(camera);
}
else
{
INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error);
result = EFail;
}
__MM_HEAP_MARKEND;
return result;
}