// Copyright (c) 2003-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:

//

/**

 @file TestSteps.cpp

*/

#include <e32math.h>

#include <c32comm.h>

#include <in_sock.h>

#include "ss_pman.h"

#include "TestMgr.h"

#include "es_mbman.h"

#include <testexecutelog.h>

#include "TestSteps.h"

#include "main.h"

//

// Construction/Destruction

//

CPPPANVL::CPPPANVL()

	{

	SetTestStepName(KPPPANVL);

	}

CPPPANVL::~CPPPANVL()

	{ }

#if defined (__WINS__)

#define PDD_NAME _L("ECDRV")

#define LDD_NAME _L("ECOMM")

#define LDD_FNAME _L("ECOMM")

#else

#define PDD_NAME _L("EUART1")

#define LDD_NAME _L("ECOMM")

#define LDD_FNAME _L("FCOMM")

#endif

void CPPPANVL::CommInitL(TBool aEnhanced)

	{

	TInt err=User::LoadPhysicalDevice(PDD_NAME);

	if (!(err==KErrNone || err==KErrAlreadyExists))

		{

		ERR_PRINTF1(_L("Failed load physical device"));

		User::Leave(err);

		}

#if defined PDD2_NAME

# if defined (__EPOC32__)

	TMachineInfoV1Buf info;

	TEST_CHECKL(UserHal::MachineInfo(info),KErrNone,_L("Failed load physical device"));

	if (info().iMachineName.Compare(_L("PROTEA_RACKC"))==0

		|| info().iMachineName.Compare(_L("PROTEA_RACKD"))==0)

		{

# endif //__EPOC32__

		err = User::LoadPhysicalDevice(PDD2_NAME);

		if (err!=KErrNone && err!=KErrAlreadyExists)

			User::Leave(err);

# if defined (__EPOC32__)

		}

# endif //__EPOC32__

#endif //PDD2_NAME

	if (aEnhanced)

		err=User::LoadLogicalDevice(LDD_FNAME);

	else

		err=User::LoadLogicalDevice(LDD_NAME);

	if (err!=KErrNone && err!=KErrAlreadyExists)

		{

		ERR_PRINTF2(_L("Failed load physical device: %s"), aEnhanced ? LDD_FNAME : LDD_NAME);

		User::Leave(err);

		}

 	_LIT(KPhbkSyncCMI, "phbsync.cmi");

    err = StartC32WithCMISuppressions(KPhbkSyncCMI);

	if (err!=KErrNone && err!=KErrAlreadyExists)

		{

		ERR_PRINTF1(_L("Failed to start comm process"));

		User::Leave(err);

		}

	}

void CPPPANVL::StartClientL()

	{

	CTestMgr* pMgr= CTestMgr::NewL(Logger(), this);

	CleanupStack::PushL(pMgr);

	pMgr->StartEngineL();

	// set the mgr going

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy();  // pMgr

	}

TVerdict CPPPANVL::doTestStepL()

	{

	SetTestStepResult(EPass);

	INFO_PRINTF1(_L("------------------------------------------"));

	INFO_PRINTF1(_L("-------- PPP <-> ANVL test -----------"));

	INFO_PRINTF1(_L("------------------------------------------"));

	INFO_PRINTF1(_L("Initialising test environment"));

	CTrapCleanup* pTrapCleanup=CTrapCleanup::New();

	if (!pTrapCleanup)

		{

		INFO_PRINTF1(_L("Failed to allocate CTrapCleanup object"));

		return EFail;

		}

	// initialise serial comms

	TInt err=KErrNone;

	TRAP(err, CommInitL(EFalse));

	TEST(err == KErrNone);

	if (err)

		{

		INFO_PRINTF1(_L("Failed to init Comm"));

		return EFail;

		}

	CActiveScheduler* pActiveScheduler=new CActiveScheduler;

	if (!pActiveScheduler)

		{

		INFO_PRINTF1(_L("Failed to allocate CActiveScheduler object"));

		return EFail;

		}

	CActiveScheduler::Install(pActiveScheduler);

	TRAP(err, doCreateMBufL())

	delete pActiveScheduler;

	delete pTrapCleanup;

	return TestStepResult();

	}

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;

void CPPPANVL::doCreateMBufL()

	{

	TInt err;

    // Initialize the MBuf manager

   	MMBufSizeAllocator *mBufSizeAllocator;

    CMBufManager *mbufMgr = CMBufManager::NewL(KMBuf_MaxAvail, mBufSizeAllocator);

	CleanupStack::PushL(mbufMgr);

	if (mbufMgr && mBufSizeAllocator)

		{

		// configure the mbuf size allocation info

		mBufSizeAllocator->AddL(KMBuf_MBufSize,    KMBuf_InitialAllocation, KMBuf_MinGrowth, KMBuf_GrowthThreshold);

		mBufSizeAllocator->AddL(KMBuf_MBufSizeBig, KMBuf_InitialAllocation, KMBuf_MinGrowth, KMBuf_GrowthThreshold);

		}

	// Go go!!!

	TRAP(err, StartClientL());

	TEST(err == KErrNone);

	if (err)

		{

		INFO_PRINTF1(_L("Leave in StartClientL()"));

		}

	INFO_PRINTF1(_L("Cleaning up test environment"));

	CleanupStack::PopAndDestroy(mbufMgr);

	}