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

// 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,	"");

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;

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

				test_NotNull(pval);

				//

				r = HcrSimTest.GetData(id, dval);

				test_KErrNone(r);

				//

				TUint16 actuallength;

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

				test_KErrNone(r);

				//

				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;

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

				test_NotNull(pval);

				//

				r = HcrSimTest.GetString(id, dval);

				test_KErrNone(r);

				//

				TUint16 actuallength;

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

				test_KErrNone(r);

				//

				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;

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

				test_NotNull(pval);

				//

				TUint16 actuallength;

				r = HcrSimTest.GetArray(id, setting->iName.iLen, 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;

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

				test_NotNull(pval);

				//

				TUint16 actuallength;

				r = HcrSimTest.GetArray(id, setting->iName.iLen, 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();

			}

		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();

			}

		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 / 2), 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);

			}

		}

	}

void HcrSimSettingProperties(SSettingC* aRepository, TUint aNumberOfSettings)

	{

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

	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);

		TSettingType type = ETypeUndefined;

		TUint16 size = KMaxSettingLength + 1;

		r = HcrSimTest.GetTypeAndSize(id, type, size);

		test_KErrNone(r);

		switch (setting->iName.iType)

			{

			case ETypeInt32:

			case ETypeInt16:

			case ETypeInt8:

			case ETypeBool:

			case ETypeUInt32:

			case ETypeUInt16:

			case ETypeUInt8:

			case ETypeLinAddr:

				test_Equal(setting->iName.iType, type);

				test_Equal(0, size);

				break;

				// Fall-through

			case ETypeBinData:

			case ETypeText8:

			case ETypeArrayInt32:

			case ETypeArrayUInt32:

			case ETypeInt64:

			case ETypeUInt64:

				test_Equal(setting->iName.iType, type);

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

				break;

			default:

				test(EFalse);

			}

		test.Printf(_L("."));

		}

	test.Printf(_L("\n"));

	}

void HcrSimMultipleGet(SSettingC* aRepository, TUint aNumberOfSettings)

	{

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

	TInt r;

	SSettingId largesetting;

	largesetting.iCat = 0;

	largesetting.iKey = 0;

	SSettingC* setting;

	SSettingId id;

	id.iCat = 0;

	id.iKey = 0;

	test.Start(_L("Multiple Get on individual settings"));

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

		{

		if (setting->iName.iType < 0x00010000)

			{

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

			TInt i;

			TInt32 val;

			TSettingType type;

			TInt err;

		    test.Next(_L("Multiple Get, with non-existing category or element id"));

			// Try all permutations of optional values

		    // i == 0 || i == 1     Just a single setting from the repostitory

		    // i == 2 || i == 3     Valid category and invalid element id

		    // i == 4 || i == 5     Invalid category and valid element id 

		    // i == 6 || i == 7     Invalid category and element id 

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

				{

				//Just a single setting from the repository

				if(i == 0 || i == 1)

					{

					//test.Printf(_L("Single setting, valid element && valid category\n"));

					id.iCat = setting->iName.iId.iCat;

					id.iKey = setting->iName.iId.iKey;

					//test.Printf(_L("-Permutation %02x\n"), i);

					r = HcrSimTest.GetWordSettings(1, &id, &val,

							(i & 0x1  ? &type : NULL), &err);

					//HCR should return 1

					test_Equal(1, r);

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

					if (i & 0x1)

						{

						test_Equal(setting->iName.iType, type);

						}

					test_KErrNone(err);

					}

				//Valid category and invalid element id

				if(i == 2 || i == 3)

					{

					//test.Printf(_L("Single setting, invalid element && valid category\n"));

					id.iCat = setting->iName.iId.iCat;

					id.iKey = KTestInvalidSettingId;

					r = HcrSimTest.GetWordSettings(1, &id, &val,

							(i & 0x1  ? &type : NULL), &err);

					//HCR should return 0

					test_Equal(0, r);

					test_Equal(0, val);

					if (i & 0x1)

						{

						//HCR returns ETypeUndefined

						test_Equal(0, type);

						}

					test_Equal(KErrNotFound,err);