// 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:

// camera1_test.cpp

// in its implementation.

// 

//

/**

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

 @publishedPartner

 @prototype 9.1

*/

#include <e32test.h>

#include <e32svr.h>

#include <e32def.h>

#include <e32def_private.h>

#include "convert1.h"

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

RConvert1 Convert;

RConvert1::TConfigBuf ConfigBuf;

_LIT(KConvert1FileName,"convert1_ldd");

_LIT8(KTestData1,"0123456789ABCDEF");

_LIT8(KTestData2,"1032547698@CBEDG");

class RHeapFriend : public RHeap

	{

public: RChunk Chunk() { return *(RChunk*)&iChunkHandle; };

	};

GLDEF_C TInt E32Main()

    {

	test.Title();

	TInt r;

	TRequestStatus s;

	test.Start(_L("Load Device"));

	r=User::LoadLogicalDevice(KConvert1FileName);

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

	__KHEAP_MARK;

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

	RDevice device;

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

	test(r==KErrNone);

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

	RConvert1::TCaps caps;

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

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

	device.GetCaps(capsPckg);

	TVersion expectedVer(RConvert1::VersionRequired());

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

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

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

	test(caps.iMaxChannels>0);

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

	device.Close();

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

	r=Convert.Open();

	test(r==KErrNone);

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

	RConvert1::TConfig& config=ConfigBuf();

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

	r=Convert.GetConfig(ConfigBuf);

	test(r==KErrNone);

	// Check config values

	const TInt KDefaultBufferSize(config.iBufferSize);

	test(KDefaultBufferSize!=0);

	test(config.iSpeed!=0);

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

	config.iBufferSize = KDefaultBufferSize*2;

	config.iCreateInputChunk = ETrue;

	test.Printf(_L("config = %d,%d,%d"),config.iBufferSize,config.iCreateInputChunk,config.iSpeed);

	r=Convert.SetConfig(ConfigBuf);

	test.Printf(_L("result = %d"),r);

	test(r==KErrNone);

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

	ConfigBuf.FillZ();

	r=Convert.GetConfig(ConfigBuf);

	test(r==KErrNone);

	test(config.iBufferSize==KDefaultBufferSize*2);

	test.Next(_L("Check access by wrong client"));

	RConvert1 ldd2=Convert;

	r=((RHandleBase&)ldd2).Duplicate(RThread(),EOwnerProcess);

	test(r==KErrAccessDenied);

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

	ldd2=Convert;

	r=((RHandleBase&)ldd2).Duplicate(RThread(),EOwnerThread);

	test(r==KErrNone);

	((RHandleBase&)ldd2).Close();

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

	TUint8* chunkBase = Convert.InChunk().Base();

	{

	test.Next(_L("Convert a descriptor"));

	Convert.Convert(KTestData1,s);

	User::WaitForRequest(s);

	r = s.Int();

	test(r>=0);

	TPtrC8 out(Convert.OutChunk().Base()+r,KTestData1().Size());

	test(out==KTestData2);

	test.Next(_L("Convert a descriptor (too big)"));

	RBuf8 big;

	test(big.CreateMax(config.iBufferSize+1)==KErrNone);

	Convert.Convert(big,s);

	User::WaitForRequest(s);

	r = s.Int();

	test(r==KErrTooBig);

	test.Next(_L("Convert a descriptor (max length)"));

	big.SetLength(big.Length()-1);

	Convert.Convert(big,s);

	User::WaitForRequest(s);

	r = s.Int();

	test(r==KErrNone);

	}

	{

	test.Next(_L("Convert a descriptor in a shared chunk"));

	TPtr8 in(chunkBase+KTestData2().Size(),KTestData2().Size());

	in = KTestData2;

	Convert.Convert(in,s);

	User::WaitForRequest(s);

	r = s.Int();

	test(r>=0);

	TPtrC8 out(Convert.OutChunk().Base()+r,KTestData2().Size());

	test(out==KTestData1);

	test.Next(_L("Convert a descriptor in a shared chunk (overflow chunk)"));

	Convert.Convert(TPtr8(chunkBase+1,config.iBufferSize),s);

	User::WaitForRequest(s);

	r = s.Int();

	test(r==KErrNone);

	}

	{

	test.Next(_L("Convert data in a shared chunk"));

	TInt offset = 2*KTestData1().Size();

	TPtr8 in(chunkBase+offset,KTestData1().Size());

	in = KTestData1;

	Convert.Convert(Convert.InChunk(),offset,KTestData1().Size(),s);

	User::WaitForRequest(s);

	r = s.Int();

	test(r>=0);

	TPtrC8 out(Convert.OutChunk().Base()+r,KTestData1().Size());

	test(out==KTestData2);

	test.Next(_L("Convert data in a non-shared chunk (should fail)"));

	Convert.Convert(((RHeapFriend&)User::Heap()).Chunk(),offset,KTestData1().Size(),s);

	User::WaitForRequest(s);

	r = s.Int();

	test(r==KErrArgument);

	test.Next(_L("Convert data in a shared chunk (overflow chunk)"));

	Convert.Convert(Convert.InChunk(),1,config.iBufferSize,s);

	User::WaitForRequest(s);

	r = s.Int();

	test(r==KErrNotFound || r==KErrArgument);

	}

	{

	test.Next(_L("Convert data in input shared chunk"));

	Convert.InBuffer() = KTestData2;

	Convert.Convert(KTestData2().Size(),s);

	User::WaitForRequest(s);

	r = s.Int();

	test(r>=0);

	TPtrC8 out(Convert.OutChunk().Base()+r,KTestData2().Size());

	test(out==KTestData1);

	}

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

	Convert.Close();

	{

	test.Next(_L("Test max number of Logical Channels"));

	RConvert1* channels = new RConvert1[caps.iMaxChannels+1];

	TInt i=0;

	// Open max number of channels

	for(; i<caps.iMaxChannels; i++)

		test(channels[i].Open()==KErrNone);

	// Try one more

	test(channels[i].Open()==KErrInUse);

	// Close all channels

	while(--i>=0)

		channels[i].Close();

	delete[] channels;

	}

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

	__KHEAP_MARKEND;

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

	User::FreeLogicalDevice(RConvert1::Name());

	test.End();

	return(0);

    }