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

// Contains definition of CTestStepCTMbufmgr which is the base class

// for all the Mbufmgr Test Step classes

//

#include <e32base.h>

// Test system includes

#include <networking/log.h>

#include <networking/teststep.h>

#include "TestStepCTMbufmgr.h"

#include "TestSuiteCTMbufmgr.h"

#include "Test20Alloc.h"

// constructor

CTest20Alloc::CTest20Alloc()

	{

	iTestStepName = _L("MBufMgrTest20");// Store the name of this test case

	}

// destructor

CTest20Alloc::~CTest20Alloc()

	{

	}

struct AllocTestStruct

{

	TInt min;

	TInt max;

	TInt allocSize;

	TInt expectedSize;

	TInt expectedBufCount;

	TInt expectedBufSizes[4];

};

const AllocTestStruct allocTests[] =

{

	{   64,   96,   96,    0, 0, {} },  // lower min nax range than pool range

	{ 1800, 2000,   96,    0, 0, {} },  // higher min nax range than pool range

	{ 1400, 1400,   96,    0, 0, {} },	// mid max range that doesn't match contain any pools

	{ 1600, 1600,   96,   96, 1, {1600} },  // highest size, allocate smaller

	{  128,  128,   96,   96, 1, {128} },  // lowest size, allocate smaller

	{  400,  400,   96,   96, 1, {400} },  // mid size, allocate smaller

	{ 1600, 1600, 3200, 3200, 2, {1600,1600} },  // highest size, allocate slightly higher

	{ 1600, 1600, 1604, 1604, 2, {1600,1600} },  // highest size, allocate slightly higher

	{  128,  128,  132,  132, 2, {128,128} },  // lowest size, allocate slightly higher

	{  400,  400,  260,  260, 1, {400} },  // mid size, allocate slightly higher

	{  128, 1600, 1604, 1604, 2, {1600,128} },  //

	{  128, 1600, 1728, 1728, 2, {1600,128} },  //

	{  128, 1600, 1856, 1856, 2, {1600,400} },  //

	{  128, 1600, 2000, 2000, 2, {1600,400} },  //

	{  128, 1600, 2128, 2128, 2, {1600,1600} },  //

	{  128, 1600, 2130, 2130, 2, {1600,1600} },  //

	{  128, 1600, 2398, 2398, 2, {1600,1600}, },  //

	{  128,  128,  300,  300, 3, {128,128,128} },  //

	{  128, 1600, 3208, 3208, 3, {1600,1600,128} },  // Edge case spotted in old algorithm by SMP work

    { 1600, 1600, 3208, 3208, 3, {1600,1600,1600} },  // Edge case spotted in old algorithm by SMP work

	{    0,    0,    0,    0,-1, {} }   // -1 indicates end of list

};

//

enum TVerdict CTest20Alloc::doTestStepL(void)

	{

	__UHEAP_MARK;

#ifdef __CFLOG_ACTIVE

	__CFLOG_CREATEL;

	__CFLOG_OPEN;

#endif

	//-------------- substep 1 --------------------

	Log(_L("  01 Create CMBufManager and install active scheduler:"));

    CleanupStack::PushL( iActSch = new(ELeave) CActiveScheduler );

	CActiveScheduler::Install(iActSch);

	MMBufSizeAllocator* MBufSizeAllocator;

	CleanupStack::PushL(CreateInstanceMBufMgrL(KMBufDefaultHeapSize / 2, MBufSizeAllocator));

	// Create some initial pools

	MBufSizeAllocator->AddL(128,  128, 64, 48);

	MBufSizeAllocator->AddL(400,  32,  16, 12);

	MBufSizeAllocator->AddL(1600, 32,  16, 12);

	TBool accumulatedFail = EFalse;

	//-------------- substep 2 --------------------

	Log(_L("  02 Alloc Tests"));

	const AllocTestStruct* test = allocTests;

	while(test->expectedBufCount != -1)

	    {

		TBool fail = EFalse;

		RMBufChain chain;

		//-------------- substep 2 --------------------

		_LIT(aLog1, "  Min %d Max %d Alloc %d");

		Log(aLog1,test->min,test->max,test->allocSize);

		chain.Alloc(test->allocSize,test->min,test->max);

		if(chain.Length() != test->expectedSize)

			{

		    _LIT(aLog2, "Error: Wrong number of bytes allocated: received %d expected %d");

			Log(aLog2,chain.Length(),test->expectedSize);

			fail = ETrue;

			}

		if( (!chain.IsEmpty() && chain.NumBufs() != test->expectedBufCount)

		 || ( chain.IsEmpty() &&               0 != test->expectedBufCount)

		  )

			{

		    _LIT(aLog3, "Error: Wrong number of buffers allocated: received %d expected %d");

			Log(aLog3,chain.IsEmpty()?0:chain.NumBufs(),test->expectedBufCount);

			fail = ETrue;

		    }

        if(!chain.IsEmpty())

            {

			RMBuf* buf = chain.First();

			int count=0;

			while(count<chain.NumBufs() && buf)

				{

				if(buf->Size() != test->expectedBufSizes[count])

				   {

					_LIT(aLog4, "Error: Expected buffer %d in the chain to be %d rather than %d");

					Log(aLog4,count,test->expectedBufSizes[count],buf->Size());

				   fail = ETrue;

			       }

				buf = buf->Next();

				count++;

				}

			}

        accumulatedFail |= fail;

		chain.Free();

		++test;

    	}

	//-------------- substep 7 --------------------

	Log(_L("  03 Clean up stack:"));

    CleanupStack::PopAndDestroy(iMBMngr);

	CActiveScheduler::Install(NULL);

	CleanupStack::PopAndDestroy(iActSch);

#ifdef __CFLOG_ACTIVE

	__CFLOG_CLOSE;

	__CFLOG_DELETE;

#endif

    __UHEAP_MARKEND;

    if (accumulatedFail)

    	{

    	return EFail;

    	}

	return EPass;

	}