// 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 the License "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:

 // in its implementation.

 // 

 //

 /**

  @file Test code for example camera device driver which uses Shared Chunks

  @publishedPartner

  @prototype 9.1

 */

 #include <e32test.h>

 #include <e32svr.h>

 #include <e32def.h>

 #include <e32def_private.h>

 #include "camera1.h"

 LOCAL_D RTest test(_L("CAMERA1_TEST"));

 RCamera1 Camera;

 RCamera1::TConfigBuf ConfigBuf;

 const TInt KMaxBuffers = 8;

 _LIT(KCamera1FileName,"camera1_ldd");

 enum TBufferMode

 	{

 	EReleaseOnCapture,

 	EReleaseInBlocks,

 	};

 void Capture(TInt aNumBuffers, TBufferMode aMode)

 	{

 	TInt r;

 	test(aNumBuffers<=KMaxBuffers);

 	test.Start(_L("SetConfig"));

 	ConfigBuf().iNumImageBuffers = aNumBuffers;

 	ConfigBuf().iFrameRate=10;

 	r=Camera.SetConfig(ConfigBuf);

 	test(r==KErrNone);

 	// Base address of chunk which contains images

 	TUint8* chunkBase=Camera.ImageChunk().Base();

 	test.Next(_L("StartCapture"));

 	r=Camera.StartCapture();

 	test(r==KErrNone);

 	test.Next(_L("Capture images..."));

 	TInt imageBuffer[KMaxBuffers]; // Array of image buffers we've received

 	memset(imageBuffer,~0,sizeof(imageBuffer)); // Initialise to 'empty' (-1)

 	TInt lastFrameCounter = -1;

 	TInt bufNum = 0;

 	// Stream load of images...

 	for(TInt i=0; i<20*aNumBuffers; i++)

 		{

 		// Stall half way through streaming test...

 		if(i==10+aNumBuffers-1)

 			{

 			test.Next(_L("Stall during image capture"));

 			User::After(500000);

 			}

 		// Get an image...

 		TRequestStatus s;

 		if(aMode==EReleaseInBlocks)

 			Camera.CaptureImage(s);

 		else

 			Camera.CaptureImage(s,imageBuffer[bufNum]);

 		User::WaitForRequest(s);

 		// imageOffset = capture result

 		TInt imageOffset=s.Int();

 		imageBuffer[bufNum] = imageOffset;

 		// Error?

 		if(imageOffset<0)

 			{

 			test.Printf(_L("Error = %d\n"),imageOffset);

 			test(0);

 			}

 		// Check image memory is accessable and get counter

 		TInt frameCounter = *(TInt*)(chunkBase+imageOffset);  // Test driver puts frame counter at image start

 		RDebug::Print(_L("Capture %08x(%04d)\n"),imageOffset,frameCounter);

 		test(frameCounter>lastFrameCounter);

 		// Move on to next buffer...

 		if(++bufNum>=aNumBuffers)

 			{

 			if(aMode==EReleaseInBlocks)

 				{

 				// Release all the image buffers we have...

 				for(bufNum=0; bufNum<aNumBuffers; bufNum++)

 					{

 					RDebug::Print(_L("Release %08x\n"),imageBuffer[bufNum]);

 					r=Camera.ReleaseImage(imageBuffer[bufNum]);

 					imageBuffer[bufNum] = -1;

 					test(r==KErrNone);

 					}

 				}

 			bufNum = 0;

 			}

 		}

 	test.Next(_L("EndCapture"));

 	r=Camera.EndCapture();

 	test(r==KErrNone);

 	test.End();

 	}

 GLDEF_C TInt E32Main()

     {

 	test.Title();

 	TInt r;

 	test.Start(_L("Loading CAMERA1 Device"));

 	r=User::LoadLogicalDevice(KCamera1FileName);

 	test(r==KErrNone || r==KErrAlreadyExists);

 	__KHEAP_MARK;

 	test.Next(_L("Open Device"));

 	RDevice device;

 	r=device.Open(RCamera1::Name());

 	test(r==KErrNone);

 	test.Next(_L("Get Device Capabilities"));

 	RCamera1::TCaps caps;

 	TPckg<RCamera1::TCaps>capsPckg(caps);

 	capsPckg.FillZ(); // Zero 'caps' so we can tell if GetCaps has really filled it

 	device.GetCaps(capsPckg);

 	TVersion expectedVer(RCamera1::VersionRequired());

 	test(caps.iVersion.iMajor==expectedVer.iMajor);

 	test(caps.iVersion.iMinor==expectedVer.iMinor);

 	test(caps.iVersion.iBuild==expectedVer.iBuild);

 	test.Next(_L("Close Device"));

 	device.Close();

 	test.Next(_L("Open Logical Channel"));

 	r=Camera.Open();

 	test(r==KErrNone);

 	test.Next(_L("GetConfig"));

 	RCamera1::TConfig& config=ConfigBuf();

 	ConfigBuf.FillZ();   // Zero 'config' so we can tell if GetConfig has really filled it

 	r=Camera.GetConfig(ConfigBuf);

 	test(r==KErrNone);

 	const TSize KDefaultImageSize(config.iImageSize);

 	test(KDefaultImageSize.iWidth!=0);

 	test(KDefaultImageSize.iHeight!=0);

 	test(config.iImageBytesPerPixel!=0);

 	test.Next(_L("StartCapture (before SetConfig has been called)"));

 	r=Camera.StartCapture();

 	test(r==KErrNotReady);

 	test.Next(_L("SetConfig"));

 	config.iImageSize.iWidth = KDefaultImageSize.iWidth/2;

 	config.iImageSize.iHeight = KDefaultImageSize.iHeight/2;

 	config.iFrameRate = 2; // Slow rate to give timing dependant tests a chance

 	config.iNumImageBuffers = 1;

 	r=Camera.SetConfig(ConfigBuf);

 	test(r==KErrNone);

 	test.Next(_L("Check handle duplication"));

 	RCamera1 Camera2=Camera;

 	r=Camera2.Duplicate(RThread(),EOwnerProcess);

 	test(r==KErrNone);

 	Camera2.Close();

 	test.Next(_L("Check config set"));

 	ConfigBuf.FillZ();

 	r=Camera.GetConfig(ConfigBuf);

 	test(r==KErrNone);

 	test(config.iImageSize.iWidth==KDefaultImageSize.iWidth/2);

 	test(config.iImageSize.iHeight==KDefaultImageSize.iHeight/2);

 	test(ConfigBuf().iFrameRate==2);

 	test(ConfigBuf().iNumImageBuffers==1);

 	test.Next(_L("Check image chunk handle"));

 	test(Camera.ImageChunk().Handle()!=KNullHandle);

 	Camera.ImageChunk().Base();

 	test.Next(_L("CaptureImage (before StartCapture has been called)"));

 	TRequestStatus s;

 	Camera.CaptureImage(s);

 	User::WaitForRequest(s);

 	test(s.Int()==KErrNotReady);

 	test.Next(_L("StartCapture"));

 	r=Camera.StartCapture();

 	test(r==KErrNone);

 	test.Next(_L("StartCapture again"));

 	r=Camera.StartCapture();

 	test(r==KErrInUse);

 	test.Next(_L("SetConfig whilst capturing"));

 	r=Camera.SetConfig(ConfigBuf);

 	test(r==KErrInUse);

 	test.Next(_L("CaptureImage"));

 	Camera.CaptureImage(s);

 	test.Next(_L("CaptureImage again (before last has completed)"));

 	TRequestStatus s2;

 	Camera.CaptureImage(s2);

 	User::WaitForRequest(s2);

 	test(s2.Int()==KErrInUse);

 	test.Next(_L("CaptureCancel"));

 	Camera.CaptureImageCancel();

 	User::WaitForRequest(s);

 	test(s.Int()==KErrCancel);

 	test.Next(_L("CaptureCancel again"));

 	Camera.CaptureImageCancel();

 	test.Next(_L("CaptureImage"));

 	Camera.CaptureImage(s);

 	User::WaitForRequest(s);

 	test(s.Int()>=0);

 	test.Next(_L("CaptureImage again (before releasing previous image)"));

 	Camera.CaptureImage(s2);

 	User::WaitForRequest(s2);

 	test(s2.Int()==KErrOverflow);

 	test.Next(_L("ReleaseImage"));

 	r=Camera.ReleaseImage(s.Int());

 	test(r==KErrNone);

 	test.Next(_L("ReleaseImage again"));

 	r=Camera.ReleaseImage(s.Int());

 	test(r==KErrNotFound);

 	test.Next(_L("CaptureImage"));

 	Camera.CaptureImage(s);

 	test.Next(_L("EndCapture"));

 	r=Camera.EndCapture();

 	test(r==KErrNone);

 	User::WaitForRequest(s);

 	test(s.Int()==KErrCancel);

 	test.Next(_L("CaptureImage streaming with 1 buffer and ReleaseOnCapture"));

 	Capture(1,EReleaseOnCapture);

 	test.Next(_L("CaptureImage streaming with 1 buffer and EReleaseInBlocks"));

 	Capture(1,EReleaseInBlocks);

 	test.Next(_L("CaptureImage streaming with 2 buffers and ReleaseOnCapture"));

 	Capture(2,EReleaseOnCapture);

 	test.Next(_L("CaptureImage streaming with 2 buffers and EReleaseInBlocks"));

 	Capture(2,EReleaseInBlocks);

 	test.Next(_L("CaptureImage streaming with 3 buffers and ReleaseOnCapture"));

 	Capture(3,EReleaseOnCapture);

 	test.Next(_L("CaptureImage streaming with 3 buffers and EReleaseInBlocks"));

 	Capture(3,EReleaseInBlocks);

 	test.Next(_L("Close Logical Channel"));

 	Camera.Close();

 	test.Next(_L("Test cleanup 1"));

 		test.Start(_L("Open Logical Channel"));

 		r=Camera.Open();

 		test(r==KErrNone);

 		test.Next(_L("Close Logical Channel"));

 		Camera.Close();

 		test.End();

 	test.Next(_L("Test cleanup 2"));

 		test.Start(_L("Open Logical Channel"));

 		r=Camera.Open();

 		test(r==KErrNone);

 		test.Next(_L("SetConfig"));

 		r=Camera.SetConfig(ConfigBuf);

 		test(r==KErrNone);

 		test.Next(_L("Close Logical Channel"));

 		Camera.Close();

 		test.End();

 	test.Next(_L("Test cleanup 2"));

 		test.Start(_L("Open Logical Channel"));

 		r=Camera.Open();

 		test(r==KErrNone);

 		test.Next(_L("SetConfig"));

 		r=Camera.SetConfig(ConfigBuf);

 		test(r==KErrNone);

 		test.Next(_L("StartCapture"));

 		r=Camera.StartCapture();

 		test(r==KErrNone);

 		test.Next(_L("Close Logical Channel"));

 		Camera.Close();

 		test.End();

 	test.Next(_L("Test cleanup 3"));

 		test.Start(_L("Open Logical Channel"));

 		r=Camera.Open();

 		test(r==KErrNone);

 		test.Next(_L("SetConfig"));

 		r=Camera.SetConfig(ConfigBuf);

 		test(r==KErrNone);

 		test.Next(_L("StartCapture"));

 		r=Camera.StartCapture();

 		test(r==KErrNone);

 		test.Next(_L("CaptureImage"));

 		Camera.CaptureImage(s);

 		User::WaitForRequest(s);

 		test.Next(_L("Close Logical Channel"));

 		Camera.Close();

 		test.End();

 	test.End();

 	User::After(500000);	// allow any async close operations to complete

 	__KHEAP_MARKEND;

 	return(0);

     }