/*
* Copyright (c) 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 <test/testexecutestepbase.h>
#include <test/testexecuteserverbase.h>

#include <e32def_private.h>

#ifdef SYMBIAN_OLD_EXPORT_LOCATION
#include <comms-infras/zerocopy_loopback_driver.h>
#else
//this header is not exported, needs to be a user include
#include "zerocopy_loopback_driver.h"
#endif

#include <comms-infras/commsbuf.h>
#include <comms-infras/commsbufpond.h>
#include <comms-infras/commsbufpondop.h>

_LIT8(KTestSendData,"abcdefghijklmnopqrstuvwxyz");
static const TInt KMBuf_MaxAvail = 393216;
static const TInt KMBuf_MBufSize = 128;
static const TInt KMBuf_MBufSizeBig = 1600;
static const TInt KMBuf_InitialAllocation = 128;
static const TInt KMBuf_MinGrowth = 64;
static const TInt KMBuf_GrowthThreshold = 40;

static const TInt KOneSecond = 1000000;


class CZCDriverTestServer : public CTestServer
	{
public:
	static CZCDriverTestServer* NewL();
	~CZCDriverTestServer();

protected:
	const TPtrC ServerName() const;
	CTestStep* CreateTestStep(const TDesC& aStepName);
	};


_LIT(KZCDriverTestName, "zc_driver_test");

class CZCDriverTestStep : public CTestStep
	{
public:

	CZCDriverTestStep()
		{
		SetTestStepName(KZCDriverTestName);
		}

protected:
	enum TVerdict doTestStepL();

	enum TVerdict doTestStepPreambleL()
		{
		SetTestStepResult(EPass);
		return TestStepResult();
		}
	};

#define TEST_VERDICT(test) if(test) {SetTestStepResult(EFail);}

enum TVerdict CZCDriverTestStep::doTestStepL()
	{
	CActiveScheduler* activeScheduler = new(ELeave) CActiveScheduler;
	CleanupStack::PushL(activeScheduler);
	CActiveScheduler::Install(activeScheduler);

	SetTestStepResult(EFail);

	// Start of testing
	INFO_PRINTF1(_L("Load Physical Device"));
	TInt r;
	r=User::LoadPhysicalDevice(KZeroCopyLoopbackPddFileName);
	TEST_VERDICT(r==KErrNone || r==KErrAlreadyExists);

	INFO_PRINTF1(_L("Load Logical Device"));
	r=User::LoadLogicalDevice(KZeroCopyLoopbackLddFileName);
	TEST_VERDICT(r==KErrNone || r==KErrAlreadyExists);

    // Initialize a commsbuf pond
    RCommsBufPondOp commsBufPond;
    RArray<TCommsBufPoolCreateInfo> createInfos;
    TCommsBufPoolCreateInfo poolInfoForLargeBufs;
    poolInfoForLargeBufs.iBufSize = KMBuf_MBufSizeBig;
    poolInfoForLargeBufs.iInitialBufs = KMBuf_InitialAllocation;
    poolInfoForLargeBufs.iGrowByBufs = KMBuf_MinGrowth;
    poolInfoForLargeBufs.iMinFreeBufs = KMBuf_GrowthThreshold;
    poolInfoForLargeBufs.iCeiling = (KMBuf_MaxAvail/2) / KMBuf_MBufSize;    
    createInfos.AppendL(poolInfoForLargeBufs);
    TCommsBufPoolCreateInfo poolInfoForSmallBufs;
    poolInfoForSmallBufs.iBufSize = KMBuf_MBufSize;
    poolInfoForSmallBufs.iInitialBufs = KMBuf_InitialAllocation;
    poolInfoForSmallBufs.iGrowByBufs = KMBuf_MinGrowth;
    poolInfoForSmallBufs.iMinFreeBufs = KMBuf_GrowthThreshold;
    poolInfoForSmallBufs.iCeiling = (KMBuf_MaxAvail/2) / KMBuf_MBufSize;
    createInfos.AppendL(poolInfoForSmallBufs);
	User::LeaveIfError(commsBufPond.Open(createInfos));
	createInfos.Close();
	
	__KHEAP_MARK;

	INFO_PRINTF1(_L("Open Device"));
	RDevice device;
	r=device.Open(RZeroCopyLoopbackDriver::Name());
	TEST_VERDICT(r==KErrNone);

	INFO_PRINTF1(_L("Get Device Capabilities"));
	RZeroCopyLoopbackDriver::TCaps caps;
	TPckg<RZeroCopyLoopbackDriver::TCaps>capsPckg(caps);
	capsPckg.FillZ(); // Zero 'caps' so we can tell if GetCaps has really filled it
	device.GetCaps(capsPckg);
	TVersion expectedVer(RZeroCopyLoopbackDriver::VersionRequired());
	TEST_VERDICT(caps.iVersion.iMajor==expectedVer.iMajor);
	TEST_VERDICT(caps.iVersion.iMinor==expectedVer.iMinor);
	TEST_VERDICT(caps.iVersion.iBuild==expectedVer.iBuild);

	INFO_PRINTF1(_L("Close Device"));
	device.Close();

	INFO_PRINTF1(_L("Open Logical Channel"));
	RZeroCopyLoopbackDriver ldd;
	r=ldd.Open();
	TEST_VERDICT(r==KErrNone);

	INFO_PRINTF1(_L("GetConfig"));
	RZeroCopyLoopbackDriver::TConfigBuf configBuf;
	configBuf.FillZ();   // Zero 'config' so we can tell if GetConfig has really filled it
	r=ldd.GetConfig(configBuf);
	TEST_VERDICT(r==KErrNone);

	RZeroCopyLoopbackDriver::TConfig& config=configBuf();
	TEST_VERDICT(config.iPddBufferSize!=0);
	TEST_VERDICT(config.iMaxSendDataSize!=0);
	TEST_VERDICT(config.iMaxReceiveDataSize!=0);

	INFO_PRINTF1(_L("SetConfig"));
	TInt speed = configBuf().iSpeed+1;
	configBuf().iSpeed = speed;
	r=ldd.SetConfig(configBuf); // Use SetConfig to change speed
	TEST_VERDICT(r==KErrNone);

	configBuf.FillZ();
	r=ldd.GetConfig(configBuf);
	TEST_VERDICT(r==KErrNone);
	TEST_VERDICT(configBuf().iSpeed==speed);
	TRequestStatus status;

	INFO_PRINTF1(_L("Check access by wrong client"));
	RZeroCopyLoopbackDriver ldd2=ldd;
	r=ldd2.Duplicate(RThread(),EOwnerProcess);
	TEST_VERDICT(r==KErrAccessDenied);

	INFO_PRINTF1(_L("Check handle duplication"));
	ldd2=ldd;
	r=ldd2.Duplicate(RThread(),EOwnerThread);
	TEST_VERDICT(r==KErrNone);
	ldd2.Close();

	INFO_PRINTF1(_L("Load pond"));
	r = ldd.LoadPond(commsBufPond);
	TEST_VERDICT(r == KErrNone);

	INFO_PRINTF1(_L("Unload pond"));
	r = ldd.UnloadPond();
	TEST_VERDICT(r == KErrNone);
	
	INFO_PRINTF1(_L("Reload pond"));
	r = ldd.LoadPond(commsBufPond);
	TEST_VERDICT(r == KErrNone);

	INFO_PRINTF1(_L("SendData"));
	TCommsBufAllocator allocator = commsBufPond.Allocator();
	RCommsBuf* buf = RCommsBuf::Alloc(KTestSendData().Length(), allocator);
	TEST_VERDICT(buf != NULL);
	buf->Reset();
	buf->Append(KTestSendData);
	ldd.SendData(status, *buf);
	User::WaitForRequest(status);
	r = status.Int();
	TEST_VERDICT(r == KErrNone);
	buf = NULL;

	INFO_PRINTF1(_L("SendData"));
	buf = RCommsBuf::Alloc(KTestSendData().Length(), allocator);
	TEST_VERDICT(buf != NULL);
	buf->Reset();
	buf->Append(KTestSendData);
	ldd.SendData(status, *buf);
	User::WaitForRequest(status);
	r=status.Int();
	TEST_VERDICT(r == KErrNone);
	buf = NULL;

	INFO_PRINTF1(_L("ReceiveData"));
	RCommsBuf* rxbuf;
	ldd.ReceiveData(status);
	User::WaitForRequest(status);
	r=status.Int();
	TEST_VERDICT(r > 0);
	rxbuf = commsBufPond.FromHandle(r);
	TEST_VERDICT(rxbuf != 0);
	TEST_VERDICT(rxbuf->Length() == KTestSendData().Size());
	TEST_VERDICT(rxbuf->DesC8() == KTestSendData);
	TBuf8<256> bufdata;
	rxbuf->Read(bufdata);
	TEST_VERDICT(bufdata == KTestSendData);
	rxbuf->Free();
	rxbuf = NULL;

	INFO_PRINTF1(_L("ReceiveData"));
	ldd.ReceiveData(status);
	User::WaitForRequest(status);
	r=status.Int();
	TEST_VERDICT(r > 0);
	rxbuf = commsBufPond.FromHandle(r);
	TEST_VERDICT(rxbuf != 0);
	TEST_VERDICT(rxbuf->Length() == KTestSendData().Size());
	TEST_VERDICT(rxbuf->DesC8() == KTestSendData);
	rxbuf->Read(bufdata);
	TEST_VERDICT(bufdata == KTestSendData);
	rxbuf->Free();
	rxbuf = NULL;

	INFO_PRINTF1(_L("ReceiveDataCancel"));
	ldd.ReceiveData(status);
	User::After(KOneSecond);
	ldd.ReceiveDataCancel();
	User::WaitForRequest(status);
	r=status.Int();
	TEST_VERDICT(r == KErrCancel);

#if 0
	INFO_PRINTF1(_L("SendDataCancel"));
	ldd.SendDataCancel();
	User::WaitForRequest(status);
	r=status.Int();
	TEST_VERDICT(r == KErrNone);
	buf = NULL;
#endif
	
	INFO_PRINTF1(_L("Unload pond"));
	r = ldd.UnloadPond();
	TEST_VERDICT(r == KErrNone);
	
	INFO_PRINTF1(_L("Close Logical Channel"));
	ldd.Close();

	__KHEAP_MARKEND;

	INFO_PRINTF1(_L("Unload Logical Device"));
	r=User::FreeLogicalDevice(RZeroCopyLoopbackDriver::Name());
	TEST_VERDICT(r==KErrNone);

	INFO_PRINTF1(_L("Unload Physical Device"));
	TName pddName(RZeroCopyLoopbackDriver::Name());
	_LIT(KVariantExtension,".template");
	pddName.Append(KVariantExtension);
	r=User::FreePhysicalDevice(pddName);
	TEST_VERDICT(r==KErrNone);

	// Close the pond
	commsBufPond.Close();
	
	// End of testing
	CleanupStack::PopAndDestroy(activeScheduler);
	
	SetTestStepResult(EPass);
	return TestStepResult();
	}


CZCDriverTestServer* CZCDriverTestServer::NewL()
/**
 * @return - Instance of the test server
 * Same code for Secure and non-secure variants
 * Called inside the MainL() function to create and start the
 * CTestServer derived server.
 */
	{
	CZCDriverTestServer* server = new (ELeave) CZCDriverTestServer();
	CleanupStack::PushL(server);
	server->StartL(server->ServerName());
	CleanupStack::Pop(server);
	return server;
	}


CZCDriverTestServer::~CZCDriverTestServer()
	{
	}


// Secure variants much simpler
// For EKA2, just an E32Main and a MainL()
LOCAL_C void MainL()
/**
 * Secure variant
 * Much simpler, uses the new Rendezvous() call to sync with the client
 */
	{
	// Leave the hooks in for platform security
#if (defined __DATA_CAGING__)
	RProcess().DataCaging(RProcess::EDataCagingOn);
	RProcess().DataCaging(RProcess::ESecureApiOn);
#endif
	CActiveScheduler* sched=NULL;
	sched=new(ELeave) CActiveScheduler;
	CActiveScheduler::Install(sched);

	CZCDriverTestServer* server = NULL;

	// Create the CTestServer derived server
	TRAPD(err,server = CZCDriverTestServer::NewL());
	if(!err)
		{
		// Sync with the client and enter the active scheduler
		RProcess::Rendezvous(KErrNone);
		sched->Start();
		}

	delete server;
	delete sched;
	}


GLDEF_C TInt E32Main()
/**
 * @return - Standard Epoc error code on process exit
 * Secure variant only
 * Process entry point. Called by client using RProcess API
 */
	{
	__UHEAP_MARK;
	CTrapCleanup* cleanup = CTrapCleanup::New();
	if(cleanup == NULL)
		{
		return KErrNoMemory;
		}
	TRAPD(err,MainL());
	delete cleanup;
	__UHEAP_MARKEND;
	return err;
    }


CTestStep* CZCDriverTestServer::CreateTestStep(const TDesC& aStepName)
/**
 * @return - A CTestStep derived instance
 * Implementation of CTestServer pure virtual
 */
	{
	CTestStep* testStep = NULL;
	if(aStepName.Compare(KZCDriverTestName) == 0)
		testStep =new CZCDriverTestStep();

	return testStep;
	}

const TPtrC CZCDriverTestServer::ServerName() const
	{
#if (!defined EKA2)
	// On EKA1 our test server is loaded as a dll.
	// So we cannot rely on the process name
	return KServerName();
#else
	// On EKA2, test server runs in its own process.
	// So we arrive at the server name using the exe from which it is loaded.
	// This is useful when doing cap tests, as we create duplicate exe's using setcap then.
	TParsePtrC serverName(RProcess().FileName());
	return serverName.Name();
#endif
	}