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

// Hardware Configuration Respoitory Test Application

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32rom.h>

#include <e32svr.h>

#include <e32hashtab.h>

#include <e32base.h>

#include "d_hcrsim.h"

#include "d_hcrsim_testdata.h"

#include "hcr_uids.h"

_LIT8(KTestFileRepos,	"filerepos.dat");

_LIT8(KTestNandRepos,	"nandrepos.dat");

_LIT8(KTestCorrupt1,	"corrupt1.dat");

_LIT8(KTestCorrupt2,	"corrupt2.dat");

_LIT8(KTestEmpty,		"empty.dat");

_LIT8(KTestMegaLarge1,	"megalarge1.dat");

_LIT8(KTestMegaLarge2,	"megalarge2.dat");

_LIT8(KTestClearRepos,	"");

static const TInt KSimOwnThread = 0;

static const TInt KSimClientThread = 1;

static TInt gHcrThread = KSimOwnThread;

//Calculation of the fraction defined by f for the number x

#define _FRACTION(x, f)    (x>f ? x/f : x)

RTest test(_L("T_HCR"));

RHcrSimTestChannel HcrSimTest;

//Helper function to compare two SSettingId parameters. It's used in 

//GetMultipleWord settings array

TInt CompareEntries (const SSettingC& a1, const SSettingC& a2)

	{

	if (a1.iName.iId.iCat > a2.iName.iId.iCat)

		return (1); 

	if (a1.iName.iId.iCat < a2.iName.iId.iCat)

		return (-1);

	// Categories are the same at this point, check keys.

	if (a1.iName.iId.iKey > a2.iName.iId.iKey)

		return (1); 

	if (a1.iName.iId.iKey < a2.iName.iId.iKey)

		return (-1);

	// Both Categories and jeys are the same here.

	return (0); 

	}

void HcrSimGetSettings(SSettingC* aRepository, TUint aNumberOfSettings)

	{

	test.Next(_L("GetSettings"));

	TInt r;

	SSettingC* setting;

	for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)

		{

		TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);

		test.Printf(_L("(0x%08x, 0x%08x)\n"), id.iCat, id.iKey);

		switch (setting->iName.iType)

			{

			case ETypeInt32:

				{

				TInt32 val;

				r = HcrSimTest.GetInt(id, val);

				test_KErrNone(r);

				test_Equal(setting->iValue.iLit.iInt32, val);

				break;

				}

			case ETypeInt16:

				{

				TInt16 val;

				r = HcrSimTest.GetInt(id, val);

				test_KErrNone(r);

				test_Equal(setting->iValue.iLit.iInt16, val);

				break;

				}

			case ETypeInt8:

				{

				TInt8 val;

				r = HcrSimTest.GetInt(id, val);

				test_KErrNone(r);

				test_Equal(setting->iValue.iLit.iInt8, val);

				break;

				}

			case ETypeBool:

				{

				TBool val;

				r = HcrSimTest.GetBool(id, val);

				test_KErrNone(r);

				test_Equal(setting->iValue.iLit.iBool, val);

				break;

				}

			case ETypeUInt32:

				{

				TUint32 val;

				r = HcrSimTest.GetUInt(id, val);

				test_KErrNone(r);

				test_Equal(setting->iValue.iLit.iUInt32, val);

				break;

				}

			case ETypeUInt16:

				{

				TUint16 val;

				r = HcrSimTest.GetUInt(id, val);

				test_KErrNone(r);

				test_Equal(setting->iValue.iLit.iUInt16, val);

				break;

				}

			case ETypeUInt8:

				{

				TUint8 val;

				r = HcrSimTest.GetUInt(id, val);

				test_KErrNone(r);

				test_Equal(setting->iValue.iLit.iUInt8, val);

				break;

				}

			case ETypeLinAddr:

				{

				TLinAddr val;

				r = HcrSimTest.GetLinAddr(id, val);

				test_KErrNone(r);

				test_Equal(setting->iValue.iLit.iAddress, val);

				break;

				}

			case ETypeBinData:

				{

				TBuf8<KMaxSettingLength> dval;

				TUint8* pval;

				TUint16 maxLen = setting->iName.iLen == 0 ? (TUint16)4: setting->iName.iLen; 

				pval = (TUint8*) User::Alloc(maxLen);

				test_NotNull(pval);

				//

				r = HcrSimTest.GetData(id, dval);

				test_KErrNone(r);

				//

				TUint16 actuallength;

				r = HcrSimTest.GetData(id, maxLen, pval, actuallength);

				test_KErrNone(r);

				//

				if(setting->iName.iLen > 0)

				    {

                    test_Equal(0, Mem::Compare(

				        setting->iValue.iPtr.iData, setting->iName.iLen,

				        pval, actuallength));

                    test_Equal(0, Mem::Compare(

				        setting->iValue.iPtr.iData, setting->iName.iLen,

				        dval.Ptr(), dval.Length()));

				    }

				User::Free(pval);

				break;

				}

			case ETypeText8:

				{

				TBuf8<KMaxSettingLength> dval;

				TText8* pval;

				TUint16 maxLen = setting->iName.iLen == 0 ? (TUint16)4: setting->iName.iLen;

				pval = (TText8*) User::Alloc(maxLen);

				test_NotNull(pval);

				//

				r = HcrSimTest.GetString(id, dval);

				test_KErrNone(r);

				//

				TUint16 actuallength;

				r = HcrSimTest.GetString(id, maxLen, pval, actuallength);

				test_KErrNone(r);

				if(setting->iName.iLen > 0)

				    {

                    test_Equal(0, Mem::Compare(

				        setting->iValue.iPtr.iString8, setting->iName.iLen,

				        pval, actuallength));

                    test_Equal(0, Mem::Compare(

				        setting->iValue.iPtr.iString8, setting->iName.iLen,

				        dval.Ptr(), dval.Length()));

				    }

				User::Free(pval);

				break;

				}

			case ETypeArrayInt32:

				{

				TInt32* pval;

				TUint16 maxLen = setting->iName.iLen == 0 ? (TUint16)4: setting->iName.iLen;

				pval = (TInt32*) User::Alloc(maxLen);

				test_NotNull(pval);

				//

				TUint16 actuallength;

				r = HcrSimTest.GetArray(id, maxLen, pval, actuallength);

				test_KErrNone(r);

				test_Equal(setting->iName.iLen, actuallength);

				TInt32* pexpected = setting->iValue.iPtr.iArrayInt32;

				TUint i;

				for (i = 0; i < setting->iName.iLen / sizeof(TInt32); i++)

					{

					test_Equal(*(pexpected + i), *(pval + i));

					}

				User::Free(pval);

				break;

				}

			case ETypeArrayUInt32:

				{

				TUint32* pval;

				TUint16 maxLen = setting->iName.iLen == 0 ? (TUint16)4: setting->iName.iLen;

				pval = (TUint32*) User::Alloc(maxLen);

				test_NotNull(pval);

				//

				TUint16 actuallength;

				r = HcrSimTest.GetArray(id, maxLen, pval, actuallength);

				test_KErrNone(r);

				//

				test_Equal(setting->iName.iLen, actuallength);

				TUint32* pexpected = setting->iValue.iPtr.iArrayUInt32;

				TUint i;

				for (i = 0; i < setting->iName.iLen / sizeof(TUint32); i++)

					{

					test_Equal(*(pexpected + i), *(pval + i));

					}

				User::Free(pval);

				break;

				}

			case ETypeInt64:

				{

				TInt64 val;

				r = HcrSimTest.GetInt(id, val);

				test_KErrNone(r);

				test_Equal(*setting->iValue.iPtr.iInt64, val);

				break;

				}

			case ETypeUInt64:

				{

				TUint64 val;

				r = HcrSimTest.GetUInt(id, val);

				test_KErrNone(r);

				test_Equal(*setting->iValue.iPtr.iUInt64, val);

				break;

				}

			default:

				test(EFalse);

			}

		}

	}

void HcrSimGetSettingsNegative(SSettingC* aRepository, TUint aNumberOfSettings)

	{

	test.Next(_L("GetSettingsNegative"));

	TInt r;

	SSettingC* setting;

	for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)

		{

		TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);

		test.Printf(_L("(0x%08x, 0x%08x)\n"), id.iCat, id.iKey);

		if (setting->iName.iType != ETypeInt32)

			{

			TInt32 val;

			r = HcrSimTest.GetInt(id, val);

			test_Equal(KErrArgument, r);

			}

		if (setting->iName.iType != ETypeInt16)

			{

			TInt16 val;

			r = HcrSimTest.GetInt(id, val);

			test_Equal(KErrArgument, r);

			}

		if (setting->iName.iType != ETypeInt8)

			{

			TInt8 val;

			r = HcrSimTest.GetInt(id, val);

			test_Equal(KErrArgument, r);

			}

		if (setting->iName.iType != ETypeBool)

			{

			TBool val;

			r = HcrSimTest.GetBool(id, val);

			test_Equal(KErrArgument, r);

			}

		if (setting->iName.iType != ETypeUInt32)

			{

			TUint32 val;

			r = HcrSimTest.GetUInt(id, val);

			test_Equal(KErrArgument, r);

			}

		if (setting->iName.iType != ETypeUInt16)

			{

			TUint16 val;

			r = HcrSimTest.GetUInt(id, val);

			test_Equal(KErrArgument, r);

			}

		if (setting->iName.iType != ETypeUInt8)

			{

			TUint8 val;

			r = HcrSimTest.GetUInt(id, val);

			test_Equal(KErrArgument, r);

			}

		if (setting->iName.iType != ETypeLinAddr)

			{

			TLinAddr val;

			r = HcrSimTest.GetLinAddr(id, val);

			test_Equal(KErrArgument, r);

			}

		if (setting->iName.iType != ETypeBinData)

			{

			TBuf8<KMaxSettingLength> dval;

			TUint8* pval;

			pval = (TUint8*) User::Alloc(setting->iName.iLen);

			test_NotNull(pval);

			//

			r = HcrSimTest.GetData(id, dval);

			test_Equal(KErrArgument, r);

			//

			TUint16 actuallength;

			r = HcrSimTest.GetData(id, setting->iName.iLen, pval, actuallength);

			test_Equal(KErrArgument, r);

			//

			User::Free(pval);

			}

		else if (setting->iName.iLen > 1)

			{

			RBuf8 dval;

			r = dval.Create(setting->iName.iLen - 1);

			test_KErrNone(r);

			r = HcrSimTest.GetData(id, dval);

			test_Equal(KErrTooBig, r);

			dval.Close();

			TUint8* pval;

			pval = (TUint8*) User::Alloc(setting->iName.iLen);

			test_NotNull(pval);

			//

			TUint16 actuallength;

			r = HcrSimTest.GetData(id, (unsigned short)( setting->iName.iLen - 1), pval, actuallength);

			test_Equal(KErrTooBig, r);

			//

			User::Free(pval);

			}

		if (setting->iName.iType != ETypeText8)

			{

			TBuf8<KMaxSettingLength> dval;

			TText8* pval;

			pval = (TText8*) User::Alloc(setting->iName.iLen);

			test_NotNull(pval);

			//

			r = HcrSimTest.GetString(id, dval);

			test_Equal(KErrArgument, r);

			//

			TUint16 actuallength;

			r = HcrSimTest.GetString(id, setting->iName.iLen, pval, actuallength);

			test_Equal(KErrArgument, r);

			//

			User::Free(pval);

			}

		else if (setting->iName.iLen > 1)

			{

			RBuf8 dval;

			r = dval.Create(setting->iName.iLen - 1);

			test_KErrNone(r);

			r = HcrSimTest.GetString(id, dval);

			test_Equal(KErrTooBig, r);

			dval.Close();

			TText8* pval;

			pval = (TText8*) User::Alloc(setting->iName.iLen);

			test_NotNull(pval);

			//

			TUint16 actuallength;

			r = HcrSimTest.GetString(id, (unsigned short)(setting->iName.iLen >> 1), pval, actuallength);

			test_Equal(KErrTooBig, r);

			//

			User::Free(pval);

			}

		if (setting->iName.iType != ETypeArrayInt32)

			{

			TInt32* pval;

			pval = (TInt32*) User::Alloc(setting->iName.iLen);

			test_NotNull(pval);

			//

			TUint16 actuallength;

			r = HcrSimTest.GetArray(id, setting->iName.iLen, pval, actuallength);

			test_Equal(KErrArgument, r);

			//

			User::Free(pval);

			}

		else

			{

			TInt32* pval;

			pval = (TInt32*) User::Alloc(setting->iName.iLen);

			test_NotNull(pval);

			//

			TUint16 actuallength;

			r = HcrSimTest.GetArray(id, (TUint16) (setting->iName.iLen >> 1), pval, actuallength);

			test_Equal(KErrTooBig, r);

			//

			User::Free(pval);

			}

		if (setting->iName.iType != ETypeArrayUInt32)

			{

			TUint32* pval;

			pval = (TUint32*) User::Alloc(setting->iName.iLen);

			test_NotNull(pval);

			//

			TUint16 actuallength;

			r = HcrSimTest.GetArray(id, setting->iName.iLen, pval, actuallength);

			test_Equal(KErrArgument, r);

			//

			User::Free(pval);

			}

		if (setting->iName.iType != ETypeInt64)

			{

			TInt64 val;

			r = HcrSimTest.GetInt(id, val);

			test_Equal(KErrArgument, r);

			}

		if (setting->iName.iType != ETypeUInt64)

			{

			TUint64 val;

			r = HcrSimTest.GetUInt(id, val);

			test_Equal(KErrArgument, r);

			}

		if(setting->iName.iType == ETypeBinData)

		    {

		    TUint8* valBuf;

		    TUint8* nullBuf = NULL;

		    //

		    TUint16 actuallength;

		    TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);

		    valBuf = (TUint8*) User::Alloc(KMaxSettingLength);

		    test_NotNull(valBuf);

		    //MaxLength = 0

		    r = HcrSimTest.GetData(id, 0, valBuf, actuallength);

		    test_Equal(KErrArgument, r);

		    //buffer is not provided

		    r = HcrSimTest.GetData(id, KMaxSettingLength, nullBuf, actuallength);

		    test_Equal(KErrArgument, r);

		    //neither buffer is provided nor MaxLength is not zero 

		    r = HcrSimTest.GetData(id, 0, nullBuf, actuallength);

		    test_Equal(KErrArgument, r);

		    //descriptor MaxLength is zero

		    //Default constructor sets the MaxLength to zero, so we don't need to call Create(0)

		    //We also don't need to call Close() for this buffer as well.

		    RBuf8 nullDes;

		    r = HcrSimTest.GetData(id, nullDes);

		    test_Equal(KErrArgument, r);

		    //

		    User::Free(valBuf);

		    }

		if(setting->iName.iType == ETypeText8)

		    {

		    TUint8* valBuf;

		    TUint8* nullBuf = NULL;

		    //

		    TUint16 actuallength;

		    TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);

		    valBuf = (TUint8*) User::Alloc(KMaxSettingLength);

		    test_NotNull(valBuf);

		    //MaxLength = 0

		    r = HcrSimTest.GetString(id, 0, valBuf, actuallength);

		    test_Equal(KErrArgument, r);

		    //buffer is not provided

		    r = HcrSimTest.GetString(id, KMaxSettingLength, nullBuf, actuallength);

		    test_Equal(KErrArgument, r);

		    //neither buffer is not provided nor the aMaxLen is not non-zero

		    r = HcrSimTest.GetString(id, 0, nullBuf, actuallength);

		    test_Equal(KErrArgument, r);

		    //descriptor MaxLength is zero

		    //Default constructor sets the MaxLength to zero, so we don't need to call Create(0)

		    //We also don't need to call Close() for this buffer as well.

		    RBuf8 nullDesc;

		    r = HcrSimTest.GetString(id, nullDesc);

		    test_Equal(KErrArgument, r);