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

// Implementation of BCA Test Proxy

// The proxy encapsulates test logging and error checking.

// 

//

/**

 @file

*/

#include "bcatestproxy.h"

#include <test/testexecutelog.h>

// Note on log usage:

// We reuse the macros defined for TestExecute. 

// The macros rely on the objects' ::Logger method to return the logger instance

using namespace te_xxBcaUnitTests; // All xxBCA tests

CExecutor::CExecutor(MBca& aBca):

	CActive(EPriorityStandard),

	iBca(aBca)

	{

	CActiveScheduler::Add(this);

	}

CExecutor::~CExecutor()

	{

	Cancel();

	}

void CExecutor::Exec()

	{		

	CActiveScheduler::Start();

	}

TInt CExecutor::CompletionError()

	{

	return iCompletionError;

	}

void CExecutor::RunL()

	{

	iCompletionError = iStatus.Int();

	CActiveScheduler::Stop();

	}

// MUST be provided, else AS crashes when we force completion.

void CExecutor::DoCancel()

	{

	// Do nothing.

	}

void CExecutor::ForceCompletion(TInt err)

	{

	if(IsActive())

		{

		TRequestStatus* s = &iStatus;

		User::RequestComplete(s, err);

		}

	}

CWriter::CWriter(MBca& aBca):

	CExecutor(aBca)

	{}

CWriter::~CWriter()

	{

	}

void CWriter::Write(const TDesC8& aPkt)

	{

	iBca.Write(iStatus, aPkt);

	SetActive();

	}

void CWriter::DoCancel()

	{

	iBca.CancelWrite();

	}

CReader::CReader(MBca& aBca):

	CExecutor(aBca)

	{}

void CReader::Read(TDes8& aPkt)

	{

	iBca.Read(iStatus, aPkt);

	SetActive();

	}

void CReader::DoCancel()

	{

	iBca.CancelRead();

	}

CReader::~CReader()

	{

	}

/**

C++ Constructor 

@param aLogProvider test logger owner

@param aProxyName the name of this test proxy, to be used for logging purposes.

*/

CBcaTestProxy::CBcaTestProxy(CTestStep& aLogProvider, const TDesC& aProxyName):

	iLogProvider(aLogProvider),

	iProxyName(aProxyName)

	{

	}

/** Obtains TestStep logger

required for the logging macros to work. 

@return TestStep's logger */

CTestExecuteLogger& CBcaTestProxy::Logger()

	{

	return iLogProvider.Logger();

	}

/**

Verifies that an error code is equal to the expected one.

if aCodeToVerify != aExpectedErrorCode, leaves with KErrGeneral

@param aCodeToVerify error code 

@param aExpectedErrCode expected error code

@leave see above  */

void CBcaTestProxy::VerifyErrCodeL(TInt aCodeToVerify, TInt aExpectedErrCode)

	{

	if(aCodeToVerify == aExpectedErrCode)

		{

		INFO_PRINTF3(_L("[%S]::Error code[%d] as expected."), &iProxyName, aCodeToVerify);

		}

	else

		{

		ERR_PRINTF4(_L("[%S]: ERROR: Error code[%d], but expected[%d]"), &iProxyName, aCodeToVerify, aExpectedErrCode);

		User::Leave(KErrArgument);

		}

	}

void CBcaTestProxy::Release()

	{

	INFO_PRINTF2(_L("[%S]::Release"), &iProxyName);

	ASSERT(iBca);

	iBca->Release(); // delete the BCA

	iBca = NULL;

	// Don't delete our memory. Deriving class handles creation / deletion

	}

void CBcaTestProxy::Open(const TDesC& aChannelId) 

	{

	INFO_PRINTF3(_L("[%S]::Open on channel [%S]"), &iProxyName, &aChannelId);	

	ASSERT(iBca);	

	iBca->Open(iOpenRequest, aChannelId);

	}

void CBcaTestProxy::WaitForOpenL(TInt aExpectedErr)

	{	

	INFO_PRINTF3(_L("[%S]::WaitForOpenL, expecting error[%d]"), &iProxyName, aExpectedErr);

	User::WaitForRequest(iOpenRequest);

	VerifyErrCodeL(iOpenRequest.Int(), aExpectedErr);

	}

void CBcaTestProxy::Close()

	{

	INFO_PRINTF2(_L("[%S]::Close"), &iProxyName);

	ASSERT(iBca);

	iBca->Close();

	iReader->Cancel();

	iWriter->Cancel();

	}

void CBcaTestProxy::Shutdown()

	{

	INFO_PRINTF2(_L("[%S]::Shutdown"), &iProxyName);

	ASSERT(iBca);

	iBca->Shutdown(iShutdownRequest);

	}

void CBcaTestProxy::WaitForShutdownL(TInt aExpectedErr)

	{

	INFO_PRINTF3(_L("[%S]::WaitForShutdownL, expecting error[%d]"), &iProxyName, aExpectedErr);

	User::WaitForRequest(iShutdownRequest);

	VerifyErrCodeL(iShutdownRequest.Int(), aExpectedErr);

	iReader->Cancel();

	iWriter->Cancel();

	}

void CBcaTestProxy::Read(TDes8& aBuf)

	{

	INFO_PRINTF2(_L("[%S]::Read"), &iProxyName);

	ASSERT(iBca);

	iReader->Read(aBuf);

	}

void CBcaTestProxy::WaitForReadL(TInt aExpectedErr)

	{

	INFO_PRINTF3(_L("[%S]::WaitForReadL, expecting error[%d]"), &iProxyName, aExpectedErr);

	iReader->Exec();

	VerifyErrCodeL(iReader->CompletionError(), aExpectedErr);

	}

void CBcaTestProxy::Write(const TDesC8& aBuf)

	{

	INFO_PRINTF2(_L("[%S]::Write"), &iProxyName);

	ASSERT(iBca);

	iWriter->Write(aBuf);

	}

void CBcaTestProxy::WaitForWriteL(TInt aExpectedErr)

	{

	INFO_PRINTF3(_L("[%S]::WaitForWriteL, expecting error[%d]"), &iProxyName, aExpectedErr);

	iWriter->Exec();

	VerifyErrCodeL(iWriter->CompletionError(), aExpectedErr);

	}

void CBcaTestProxy::CancelRead() 

	{

	INFO_PRINTF2(_L("[%S]::CancelRead"), &iProxyName);

	ASSERT(iBca);

	iReader->Cancel();

	}

void CBcaTestProxy::CancelWrite()

	{

	INFO_PRINTF2(_L("[%S]::CancelWrite"), &iProxyName);

	iWriter->Cancel();

	} 

void CBcaTestProxy::Ioctl(TInt aOptLevel, TInt aOptName, TDes8& aOpt)

	{

	INFO_PRINTF4(_L("[%S]::Ioctl Level=[%d] Name=[%d]"), &iProxyName, aOptLevel, aOptName);

	ASSERT(iBca);

	iBca->Ioctl(iIoctlRequest, aOptLevel, aOptName, aOpt);

	}

void CBcaTestProxy::WaitForIoctlL(TInt aExpectedErr)

	{

	INFO_PRINTF3(_L("[%S]::WaitForIoctL, expecting error[%d]"), &iProxyName, aExpectedErr);

	User::WaitForRequest(iIoctlRequest);

	VerifyErrCodeL(iIoctlRequest.Int(), aExpectedErr);

	}

void CBcaTestProxy::CancelIoctl()

	{

	INFO_PRINTF2(_L("[%S]::CancelIoctl"), &iProxyName);

	ASSERT(iBca);

	iBca->CancelIoctl();

	}

/** 

C++ constructor */

CxxBcaProxy::CxxBcaProxy(CTestStep& aLogger, const TDesC& aProxyName):

	CBcaTestProxy(aLogger, aProxyName)

	{

	}

/** 

Standard construction 

@param aLogger TestStep logger

@param aProxyName proxy name for logging

@leave if construction fails. */

CxxBcaProxy* CxxBcaProxy::NewL(CTestStep& aLogger, const TDesC& aProxyName)

	{

	CxxBcaProxy* self = new (ELeave)CxxBcaProxy(aLogger, aProxyName);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Standard construction */	

void CxxBcaProxy::ConstructL()

	{

	_LIT(KxxBcaDllName, "C32Bca");

	TInt loadErr = iBcaDll.iObj.Load(KxxBcaDllName);

	if(KErrNone != loadErr)

		{

		ERR_PRINTF4(_L("[%S]::ConstructL: Failed to load library[%S], error[%d]. Leaving."), &iProxyName, KxxBcaDllName, loadErr);	

		User::Leave(loadErr);

		}

	static const int KNewBcaFactoryProcOrdinal(1);

	TNewBcaFactoryProcL newBcaFactoryProcL = 

		(TNewBcaFactoryProcL)iBcaDll.iObj.Lookup(KNewBcaFactoryProcOrdinal);

	if(!newBcaFactoryProcL) // can't use User::LeaveIfNull, becuase it returns KErrNoMemory

		{

		ERR_PRINTF2(_L("[%S]::ConstructL: Failed to locate NewBcaFactoryL entry point."), &iProxyName);	

		User::Leave(KErrBadLibraryEntryPoint);

		}

	MBcaFactory* bcaFactory = NULL; // We need to create only one BCA

	TRAPD(err, bcaFactory = newBcaFactoryProcL());

	if(KErrNone != err)

		{

		ERR_PRINTF3(_L("[%S]::ConstructL: NewBcaFactoryL left with[%d]."), &iProxyName, err);	

		User::Leave(KErrCompletion);

		}

	ASSERT(bcaFactory); // we should not get NULL. The factory function should leave instead.

	CleanupReleasePushL(*bcaFactory);	

	iBca = bcaFactory->NewBcaL();

	CleanupStack::PopAndDestroy(bcaFactory);

	ASSERT(iBca);

	iReader = new (ELeave)CReader(*iBca);

	iWriter = new (ELeave)CWriter(*iBca);

	}

void CxxBcaProxy::Release()

	{

	INFO_PRINTF2(_L("[%S]::CxxBcaProxy::Release: deleting proxy."), &iProxyName);

	CBcaTestProxy::Release();

	if(iReader->IsActive())

		{

		iReader->ForceCompletion(KErrCancel);

		}

	if(iWriter->IsActive())

		{

		iWriter->ForceCompletion(KErrCancel);

		}

	delete iReader;

	delete iWriter;

	delete this;

	// BCA host Dll is AutoClosed.		

	}