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

// e32test/mmu/t_shbuf.cpp

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <hal.h>

#include <e32svr.h>

#include <u32hal.h>

#include "d_shbuf.h"

#include <e32shbuf.h>

#include <e32def.h>

#include <e32def_private.h>

#ifdef TEST_CLIENT_THREAD

RTest test(_L("T_SHBUF_CLIENT"));

#else

RTest test(_L("T_SHBUF_OWN"));

#endif

RShPool P1; // User-side pool

RShPool P2; // Kernel-side pool

const TInt KTestPoolSizeInBytes = 1 << 20; // 1MB

const TInt BufferSize[] = {128, 853, 4096, 5051, 131072, 1, 0}; // Last element must be 0

const TInt* PtrBufSize;

static TInt ThreadCounter = 0;

RShBufTestChannel Ldd;

_LIT(KTestSlave, "SLAVE");

_LIT(KTestLowSpaceSemaphore, "LowSpaceSemaphore");

enum TTestSlave

	{

	ETestSlaveError,

	ETestSlaveNoDeallocation,

	};

enum TTestPoolType

	{

	ETestNonPageAligned,

	ETestPageAligned,

	ETestPageAlignedGrowing,

	};

TInt Log2(TInt aNum)

	{

	TInt res = -1;

	while(aNum)

		{

		res++;

		aNum >>= 1;

		}

	return res;

	}

TInt RoundUp(TInt aNum, TInt aAlignmentLog2)

	{

	if (aNum % (1 << aAlignmentLog2) == 0)

		{

		return aNum;

		}

	return (aNum & ~((1 << aAlignmentLog2) - 1)) + (1 << aAlignmentLog2);

	}

void LoadDeviceDrivers()

	{

	TInt r;

	#ifdef TEST_CLIENT_THREAD

	r= User::LoadLogicalDevice(_L("D_SHBUF_CLIENT.LDD"));

	if (r != KErrAlreadyExists)

		{

		test_KErrNone(r);

		}

	#else

	r = User::LoadLogicalDevice(_L("D_SHBUF_OWN.LDD"));

	if (r != KErrAlreadyExists)

		{

		test_KErrNone(r);

		}

	#endif

	}

void FreeDeviceDrivers()

	{

	TInt r = User::FreeLogicalDevice(KTestShBufClient);

	test_KErrNone(r);

	r = User::FreeLogicalDevice(KTestShBufOwn);

	test_KErrNone(r);

	}

void FillShBuf(RShBuf& aBuffer, TUint8 aValue)

	{

	TUint size = aBuffer.Size();

	TUint8* base = aBuffer.Ptr();

	test(size!=0);

	test(base!=0);

	memset(base,aValue,size);

	}

TBool CheckFillShBuf(RShBuf& aBuffer, TUint8 aValue)

	{

	TUint size = aBuffer.Size();

	TUint8* base = aBuffer.Ptr();

	test(size!=0);

	test(base!=0);

	TUint8* ptr = base;

	TUint8* end = ptr+size;

	while(ptr<end)

		{

		TUint8 b = *ptr++;

		if(b!=aValue)

			{

			RDebug::Printf("CheckFillShBuf failed at offset 0x%x, expected 0x%02x but got 0x%02x ",ptr-base-1,aValue,b);

			return EFalse;

			}

		}

	return ETrue;

	}

TBool CheckNotFillShBuf(RShBuf& aBuffer, TUint8 aValue)

	{

	TUint size = aBuffer.Size();

	TUint8* base = aBuffer.Ptr();

	test(size!=0);

	test(base!=0);

	TUint8* ptr = base;

	TUint8* end = ptr+size;

	while(ptr<end)

		{

		TUint8 b = *ptr++;

		if(b==aValue)

			{

			RDebug::Printf("CheckNotFillShBuf failed at offset 0x%x, expected not 0x%02x",ptr-base-1,aValue);

			return EFalse;

			}

		}

	return ETrue;

	}

/*

@SYMTestCaseID				1

@SYMTestCaseDesc			Create pool from user-side

@SYMREQ						REQ11423

@SYMTestActions

	1. Test Thread creates a pool (P1) and passes handle to device driver.

	2. Device driver opens pool and checks its attributes.

@SYMTestExpectedResults

	All OK.

@SYMTestPriority			Critical

*/

void CreateUserPool(TTestPoolType aPoolType)

	{

	test.Next(_L("Create user-side pool"));

	TInt r;

	TInt pagesize;

	r = HAL::Get(HAL::EMemoryPageSize, pagesize);

	test_KErrNone(r);

	switch (aPoolType)

		{

		case ETestNonPageAligned:

		// Non-page-aligned pool

			{

			test.Printf(_L("Non-page-aligned\n"));

			test_Equal(0, P1.Handle());

			TShPoolCreateInfo inf(TShPoolCreateInfo::ENonPageAlignedBuffer, *PtrBufSize, KTestPoolSizeInBufs, 8);

			r = P1.Create(inf,KDefaultPoolHandleFlags);

			test_KErrNone(r);

			r = P1.SetBufferWindow(-1, ETrue);

			test_Equal(KErrNotSupported, r);

			TShPoolInfo poolinfotokernel;

			poolinfotokernel.iBufSize = *PtrBufSize;

			poolinfotokernel.iInitialBufs = KTestPoolSizeInBufs;

			poolinfotokernel.iMaxBufs = KTestPoolSizeInBufs;

			poolinfotokernel.iGrowTriggerRatio = 0;

			poolinfotokernel.iGrowByRatio = 0;

			poolinfotokernel.iShrinkHysteresisRatio = 0;

			poolinfotokernel.iAlignment = 8;

			poolinfotokernel.iFlags = EShPoolNonPageAlignedBuffer;

			r = Ldd.OpenUserPool(P1.Handle(), poolinfotokernel);

			test_KErrNone(r);

			TShPoolInfo poolinfo;

			P1.GetInfo(poolinfo);

			test_Equal(*PtrBufSize, poolinfo.iBufSize);

			test_Equal(KTestPoolSizeInBufs, poolinfo.iInitialBufs);

			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

			test_Equal(0, poolinfo.iGrowTriggerRatio);

			test_Equal(0, poolinfo.iGrowByRatio);

			test_Equal(0, poolinfo.iShrinkHysteresisRatio);

			test_Equal(8, poolinfo.iAlignment);

			test(poolinfo.iFlags & EShPoolNonPageAlignedBuffer);

			test(!(poolinfo.iFlags & EShPoolPageAlignedBuffer));

			break;

			}

		case ETestPageAligned:

		// Page-aligned pool

			{

			test.Printf(_L("Page-aligned\n"));

			test_Equal(0, P1.Handle());

			TShPoolCreateInfo inf(TShPoolCreateInfo::EPageAlignedBuffer, *PtrBufSize, KTestPoolSizeInBufs);

			r = P1.Create(inf,KDefaultPoolHandleFlags);

			test_KErrNone(r);

			r = P1.SetBufferWindow(-1, ETrue);

			test_KErrNone(r);

			TShPoolInfo poolinfo;

			P1.GetInfo(poolinfo);

			test_Equal(*PtrBufSize, poolinfo.iBufSize);

			test_Equal(KTestPoolSizeInBufs, poolinfo.iInitialBufs);

			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

			test_Equal(0, poolinfo.iGrowTriggerRatio);

			test_Equal(0, poolinfo.iGrowByRatio);

			test_Equal(0, poolinfo.iShrinkHysteresisRatio);

			test_Equal(Log2(pagesize), poolinfo.iAlignment);

			test(poolinfo.iFlags & EShPoolPageAlignedBuffer);

			test(!(poolinfo.iFlags & EShPoolNonPageAlignedBuffer));

			r = Ldd.OpenUserPool(P1.Handle(), poolinfo);

			test_KErrNone(r);

			break;

			}

		case ETestPageAlignedGrowing:

		// Page-aligned growing pool

			{

			test.Printf(_L("Page-aligned growing\n"));

			test_Equal(0, P1.Handle());

			TShPoolCreateInfo inf(TShPoolCreateInfo::EPageAlignedBuffer, *PtrBufSize, KTestPoolSizeInBufs / 2);

			// Set shrink hysteresis high so pool can't shrink

			r = inf.SetSizingAttributes(KTestPoolSizeInBufs, 25, 26, 25600);

			test_KErrNone(r);

			r = P1.Create(inf,KDefaultPoolHandleFlags);

			test_KErrNone(r);

			r = P1.SetBufferWindow(-1, ETrue);

			test_KErrNone(r);

			TShPoolInfo poolinfo;

			P1.GetInfo(poolinfo);

			test_Equal(*PtrBufSize, poolinfo.iBufSize);

			test_Equal(KTestPoolSizeInBufs / 2, poolinfo.iInitialBufs);

			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

			test_Equal(25, poolinfo.iGrowTriggerRatio);

			test_Equal(26, poolinfo.iGrowByRatio);

			test_Equal(25600, poolinfo.iShrinkHysteresisRatio);

			test_Equal(Log2(pagesize), poolinfo.iAlignment);

			test(poolinfo.iFlags & EShPoolPageAlignedBuffer);

			test(!(poolinfo.iFlags & EShPoolNonPageAlignedBuffer));

			r = Ldd.OpenUserPool(P1.Handle(), poolinfo);

			test_KErrNone(r);

			break;

			}

		default:

			test(EFalse);

		}

	}

/*

@SYMTestCaseID				2

@SYMTestCaseDesc			Create pool from kernel-side

@SYMREQ						REQ11423

@SYMTestActions

	1. Device Driver creates a pool (P2) and passes handle to this thread.

	2. Test Thread opens pool and checks its attributes.

@SYMTestExpectedResults

	1. Ok.

	2. Ok.

@SYMTestPriority			Critical

*/

void CreateKernelPool(TTestPoolType aPoolType)

	{

	test.Next(_L("Create kernel-side pool"));

	TInt r;

	TInt pagesize;

	r = HAL::Get(HAL::EMemoryPageSize, pagesize);

	test_KErrNone(r);

	TInt handle;

	switch (aPoolType)

		{

		case ETestNonPageAligned:

		// Non-page-aligned pool

			{

			test.Printf(_L("Non-page-aligned\n"));

			test_Equal(0, P2.Handle());

			TShPoolCreateInfo inf(TShPoolCreateInfo::ENonPageAlignedBuffer, *PtrBufSize, KTestPoolSizeInBufs, 8);

			r = Ldd.OpenKernelPool(inf, handle);

			test_KErrNone(r);

			P2.SetHandle(handle);

			TShPoolInfo poolinfo;

			P2.GetInfo(poolinfo);

			test_Equal(*PtrBufSize, poolinfo.iBufSize);

			test_Equal(KTestPoolSizeInBufs, poolinfo.iInitialBufs);

			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

			test_Equal(0, poolinfo.iGrowTriggerRatio);

			test_Equal(0, poolinfo.iGrowByRatio);

			test_Equal(0, poolinfo.iShrinkHysteresisRatio);

			test_Equal(8, poolinfo.iAlignment);

			test(poolinfo.iFlags & EShPoolNonPageAlignedBuffer);

			test(!(poolinfo.iFlags & EShPoolPageAlignedBuffer));

			break;

			}

		case ETestPageAligned:

		// Page-aligned pool

			{

			test.Printf(_L("Page-aligned\n"));

			test_Equal(0, P2.Handle());

			TShPoolCreateInfo inf(TShPoolCreateInfo::EPageAlignedBuffer, *PtrBufSize, KTestPoolSizeInBufs);

			r = Ldd.OpenKernelPool(inf, handle);

			test_KErrNone(r);

			P2.SetHandle(handle);

			r = P2.SetBufferWindow(-1, ETrue);

			test_KErrNone(r);

			TShPoolInfo poolinfo;

			P2.GetInfo(poolinfo);

			test_Equal(*PtrBufSize, poolinfo.iBufSize);

			test_Equal(KTestPoolSizeInBufs, poolinfo.iInitialBufs);

			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

			test_Equal(0, poolinfo.iGrowTriggerRatio);

			test_Equal(0, poolinfo.iGrowByRatio);

			test_Equal(0, poolinfo.iShrinkHysteresisRatio);

			test_Equal(Log2(pagesize), poolinfo.iAlignment);

			test(poolinfo.iFlags & EShPoolPageAlignedBuffer);

			test(!(poolinfo.iFlags & EShPoolNonPageAlignedBuffer));

			break;

			}

		case ETestPageAlignedGrowing:

		// Page-aligned pool growing

			{

			test.Printf(_L("Page-aligned growing\n"));

			test_Equal(0, P2.Handle());

			TShPoolCreateInfo inf(TShPoolCreateInfo::EPageAlignedBuffer, *PtrBufSize, KTestPoolSizeInBufs / 2);

			// Set shrink hysteresis high so pool can't shrink

			r = inf.SetSizingAttributes(KTestPoolSizeInBufs, 25, 26, 25600);

			test_KErrNone(r);

			r = Ldd.OpenKernelPool(inf, handle);

			test_KErrNone(r);

			P2.SetHandle(handle);

			r = P2.SetBufferWindow(-1, ETrue);

			test_KErrNone(r);

			TShPoolInfo poolinfo;

			P2.GetInfo(poolinfo);

			test_Equal(*PtrBufSize, poolinfo.iBufSize);

			test_Equal(KTestPoolSizeInBufs / 2, poolinfo.iInitialBufs);

			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

			test_Equal(25, poolinfo.iGrowTriggerRatio);

			test_Equal(26, poolinfo.iGrowByRatio);

			test_Equal(25600, poolinfo.iShrinkHysteresisRatio);

			test_Equal(Log2(pagesize), poolinfo.iAlignment);

			test(poolinfo.iFlags & EShPoolPageAlignedBuffer);

			test(!(poolinfo.iFlags & EShPoolNonPageAlignedBuffer));

			break;

			}

		default:

			test(EFalse);

		}

	}

/*

@SYMTestCaseID				20

@SYMTestCaseDesc			Close pool from kernel-side

@SYMREQ						REQ11423

@SYMTestActions

	1. Device Driver closes P2.

	2. Test Thread closes P2.

@SYMTestExpectedResults

	1. OK and Access Count is now 1.

	2. OK

@SYMTestPriority			Critical

*/

void CloseKernelPool()

	{

	test.Next(_L("Close kernel-side pool"));

	TInt r;

	r = Ldd.CloseKernelPool();

	test_KErrNone(r);

	P2.Close();

	// wait for memory to be freed

	r = UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, (TAny*)5000, 0);

	test_KErrNone(r);

	}

/*

@SYMTestCaseID				21

@SYMTestCaseDesc			Close pool from user-side

@SYMREQ						REQ11423

@SYMTestActions

	1. Test Thread closes P1.

	2. Device Driver closes P1.

@SYMTestExpectedResults

	1. OK and Access Count is now 1.

	2. OK.

@SYMTestPriority			Critical

*/

void CloseUserPool()

	{

	test.Next(_L("Close user-side pool"));

	TInt r;

	P1.Close();

	r = Ldd.CloseUserPool();

	test_KErrNone(r);

	// wait for memory to be freed

	r = UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, (TAny*)5000, 0);

	test_KErrNone(r);

	}

/*

@SYMTestCaseID				3

@SYMTestCaseDesc			Buffer allocation from user-side

@SYMREQ						REQ11423

@SYMTestActions

	1. Test Thread creates a shared buffer on P1.

	2. Test Thread passes buffer to Device Driver.

	3. Device Driver obtains buffer and manipulates its contents.

	4. Device Driver releases buffer.

	5. Test Thread releases buffer.

@SYMTestExpectedResults

	1. Ok.

	2. Ok.

	3. Ok.

	4. Ok.

	5. Ok. Buffer de-allocated.

@SYMTestPriority			Critical

*/

void AllocateUserBuffer()

	{

	test.Next(_L("Allocate user-side buffer"));

	TInt r;

	RShBuf buf;

	// Allocate buffer on POOL 1

	__KHEAP_MARK;

	r = buf.Alloc(P1);

	test_KErrNone(r);

	__KHEAP_CHECK(0);

	TInt i;

	TShPoolInfo poolinfo1;

	P1.GetInfo(poolinfo1);

	TInt blocks = poolinfo1.iBufSize / KTestData1().Length();

	for (i = 0; i < blocks; i++)

		{

		TPtr8(buf.Ptr() + (i * KTestData1().Length()), KTestData1().Length(),KTestData1().Length()).Copy(KTestData1());

		}

	r = Ldd.ManipulateUserBuffer(buf.Handle());

	test_KErrNone(r);

	TBuf8<64> tmp;

	P1.GetInfo(poolinfo1);

	blocks = poolinfo1.iBufSize / tmp.MaxSize();

	for (i = 0 ; i < blocks; i++)

		{

		tmp.Fill(i);

		TPtrC8 ptrc(buf.Ptr() + (i * tmp.Length()), tmp.Length());

		r = tmp.Compare(ptrc);

		test_Equal(0, r);

		}

	buf.Close();

	__KHEAP_MARKEND;

	// Allocate buffer on POOL 2

	__KHEAP_MARK;

	r = buf.Alloc(P2);

	test_KErrNone(r);

	__KHEAP_CHECK(0);

	TShPoolInfo poolinfo2;

	P2.GetInfo(poolinfo2);

	blocks = poolinfo2.iBufSize / KTestData1().Length(); // PC REMOVE

	for (i = 0; i < blocks; i++)

		{

		TPtr8(buf.Ptr() + (i * KTestData1().Length()), KTestData1().Length(),KTestData1().Length()).Copy(KTestData1());

		}

	r = Ldd.ManipulateUserBuffer(buf.Handle());

	test_KErrNone(r);

	P2.GetInfo(poolinfo2);

	blocks = poolinfo2.iBufSize / tmp.MaxSize(); // PC REMOVE