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

				//Invalid category and valid element id
				if(i == 4 || i == 5)
					{
					id.iCat = KTestInvalidCategory;
					id.iKey = setting->iName.iId.iKey;

					//test.Printf(_L("Single setting, invalid element && valid category\n"));
					r = HcrSimTest.GetWordSettings(1, &id, &val,
							(i & 0x1  ? &type : NULL), &err);
					//HCR should return 1
					test_Equal(0, r);
					test_Equal(0, val);
					if (i & 0x1)
						{
						//HCR returns ETypeUndefined
						test_Equal(0, type);
						}

					test_Equal(KErrNotFound, err);
					}
				
				//Invalid category and element id 
				if(i == 6 || i == 7)
					{
					id.iCat = KTestInvalidCategory;
					id.iKey = KTestInvalidSettingId;

					//test.Printf(_L("Single setting, invalid element && valid category\n"));
					r = HcrSimTest.GetWordSettings(1, &id, &val,
							(i & 0x1  ? &type : NULL), &err);
					//HCR should return 1
					test_Equal(0, r);
					test_Equal(0, val);
					if (i & 0x1)
						{
						//HCR returns ETypeUndefined
						test_Equal(0, type);
						}
					test_Equal(KErrNotFound, err);
					}
				}
			}
		else if (largesetting.iKey == 0)
			{
			// save for later
			largesetting.iCat = setting->iName.iId.iCat;
			largesetting.iKey = setting->iName.iId.iKey;
			}
		}

	
	
	test.Next(_L("Multiple Get, some user input parameters are wrong"));
	

	TInt nosettings = 0;
	for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
		{
		if (setting->iName.iType < 0x00010000)
			{
			nosettings++;
			}
		test_Compare(0, <, nosettings);
		}
	

	SSettingId* ids;
	TInt32* vals;
	TSettingType* types;
	TInt* errs;

	
	ids = (SSettingId*) User::Alloc(sizeof(SSettingId) * nosettings);
	test_NotNull(ids);
	vals = (TInt32*) User::Alloc(sizeof(TInt32) * nosettings);
	test_NotNull(vals);
	types = (TSettingType*) User::Alloc(sizeof(TSettingType) * nosettings);
	test_NotNull(types);
	errs = (TInt*) User::Alloc(sizeof(TInt) * nosettings);
	test_NotNull(errs);
	
	TUint n = 0;

	for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
		{
		if (setting->iName.iType < 0x00010000)
			{
			ids[n].iCat = setting->iName.iId.iCat;
			ids[n].iKey = setting->iName.iId.iKey;
			n++;
			}
		}
	test_Equal(nosettings, n);
	


    test.Next(_L("Number of settings is negative \n"));
    r = HcrSimTest.GetWordSettings(-1 * nosettings, ids, vals, types, errs);

    //HCR returns KErrArgument
    test_Equal(KErrArgument, r);
    

    test.Printf(_L("Pointer to errors array is NULL \n"));
    r = HcrSimTest.GetWordSettings(nosettings, ids, vals, types, NULL);

    //HCR returns KErrArgument
    test_Equal(KErrArgument, r);


    test.Printf(_L("Pointer to ids is NULL \n"));
    r = HcrSimTest.GetWordSettings(nosettings, NULL, vals, types, errs);

    //HCR returns KErrArgument
    test_Equal(KErrArgument, r);

	User::Free(ids);
	User::Free(vals);
	User::Free(types);
	User::Free(errs);

	
	
	test.Next(_L("Multiple Get on all settings"));
	nosettings = 0;
	for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
		{
		if (setting->iName.iType < 0x00010000)
			{
			nosettings++;
			}
		test_Compare(0, <, nosettings);
		}
	
	ids = (SSettingId*) User::Alloc(sizeof(SSettingId) * nosettings);
	test_NotNull(ids);
	vals = (TInt32*) User::Alloc(sizeof(TInt32) * nosettings);
	test_NotNull(vals);
	types = (TSettingType*) User::Alloc(sizeof(TSettingType) * nosettings);
	test_NotNull(types);
	errs = (TInt*) User::Alloc(sizeof(TInt) * nosettings);
	test_NotNull(errs);
	
	n = 0;

	for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
		{
		if (setting->iName.iType < 0x00010000)
			{
			ids[n].iCat = setting->iName.iId.iCat;
			ids[n].iKey = setting->iName.iId.iKey;
			n++;
			}
		}
	test_Equal(nosettings, n);
    
	
	// Try all permutations of optional values
	TInt i;
	for (i = 0; i < 2; i++)
		{
		r = HcrSimTest.GetWordSettings(nosettings, ids, vals,
				(i & 0x1  ? types : NULL), errs);
		//HCR returns number of found elements
		test_Equal(nosettings, r);
		
		// Check values
		n = 0;
		for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
			{
			if (setting->iName.iType < 0x00010000)
				{
				test_Equal(setting->iValue.iLit.iInt32, vals[n]);
				if (i & 0x1)
					{
					test_Equal(setting->iName.iType,types[n]);
					}
				test_KErrNone(errs[n]);
				n++;
				}
			}
		test_Equal(nosettings, n);
		}
	User::Free(ids);
	User::Free(vals);
	User::Free(types);
	User::Free(errs);
	
	test.Next(_L("Multiple Get on all settings + inexistent"));
	nosettings = 1;
	for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
		{
		if (setting->iName.iType < 0x00010000)
			{
			nosettings++;
			}
		test_Compare(0, <, nosettings);
		}
	ids = (SSettingId*) User::Alloc(sizeof(SSettingId) * nosettings);
	test_NotNull(ids);
	vals = (TInt32*) User::Alloc(sizeof(TInt32) * nosettings);
	test_NotNull(vals);
	types = (TSettingType*) User::Alloc(sizeof(TSettingType) * nosettings);
	test_NotNull(types);
	errs = (TInt*) User::Alloc(sizeof(TInt) * nosettings);
	test_NotNull(errs);
	ids[0].iCat = KTestInvalidCategory;
	ids[0].iKey = KTestInvalidSettingId;
	

	n = 1;
	for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
		{
		if (setting->iName.iType < 0x00010000)
			{
			ids[n].iCat = setting->iName.iId.iCat;
			ids[n].iKey = setting->iName.iId.iKey;
			n++;
			}
		}
	
	test_Equal(nosettings, n);

	// Try all permutations of optional values
	for (i = 0; i < 2; i++)
		{
		r = HcrSimTest.GetWordSettings(nosettings, ids, vals,
				(i & 0x1  ? types : NULL), errs);
		test_Equal(nosettings - 1, r);
		
		// Check values
		if (i & 0x1)
			{
			test_Equal(ETypeUndefined, types[0]);
			}
			test_Equal(KErrNotFound, errs[0]);

		n = 1;
		for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
			{
			if (setting->iName.iType < 0x00010000)
				{
				test_Equal(setting->iValue.iLit.iInt32, vals[n]);
				if (i & 0x1)
					{
					test_Equal(setting->iName.iType, types[n]);
					}

				test_KErrNone(errs[n]);

				n++;
				}
			}
		test_Equal(nosettings, n);
		}
	User::Free(ids);
	User::Free(vals);
	User::Free(types);
	User::Free(errs);

	test.Next(_L("Multiple Get on a large setting"));
	if (largesetting.iKey)
		{
		TInt32 value;
		TSettingType type;
		TInt theerror = 1;
		r = HcrSimTest.GetWordSettings(1, &largesetting, &value, &type, &theerror);
		test_Equal(0, r);
		test_Equal(KErrArgument, theerror);
		}
	else
		{
		test.Printf(_L("No large setting found in repositories!\n"));
		}
	test.End();
	}

void HcrSimNumSettingsInCategory(SSettingC* aRepository, TUint aNumberOfSettings)
	{
	test.Next(_L("NumSettingsInCategory"));
	TInt r;
	// Build a hash table with number of settings for each category
	RHashMap<TUint32, TInt> numsettings;
	SSettingC* setting;
	TInt* pV = NULL;
	TInt value = 0;
	for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
		{
		pV = numsettings.Find(setting->iName.iId.iCat);
		if(pV)
		    value = *pV;
		if (!pV)
			{
			r = numsettings.Insert(setting->iName.iId.iCat, 1);
			test_KErrNone(r);
			}
		else
			{
			r = numsettings.Remove(setting->iName.iId.iCat);
			test_KErrNone(r);
			r = numsettings.Insert(setting->iName.iId.iCat, value + 1);
			test_KErrNone(r);
			}
		}

	// Now compare hash table with values returned by FindNumSettingsInCategory
	RHashMap<TUint32, TInt>::TIter catiter(numsettings);
	for (;;)
		{
		const TUint32* nextcat = catiter.NextKey();
		if (!nextcat)
			{
			break;
			}
		test.Printf(_L("Category %08x\n"), *nextcat);
		const TInt* v = numsettings.Find(*nextcat);
		test_NotNull(v);
		r = HcrSimTest.FindNumSettingsInCategory(*nextcat);
		test_Equal(*v, r);
		}
	numsettings.Close();
	}

void HcrSimFindSettingsCategory(SSettingC* aRepository, TUint aNumberOfSettings)
	{
	test.Next(_L("FindSettingsCategory"));
	TInt r;
	// Build a hash table with number of settings for each category
	RHashMap<TUint32, TInt> numsettings;
	SSettingC* setting;
	TInt* pV = NULL;
	TInt value = 0;
	for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
		{
		pV = numsettings.Find(setting->iName.iId.iCat);
		if(pV)
		    value = *pV;
		if (!pV)
			{
			r = numsettings.Insert(setting->iName.iId.iCat, 1);
			test_KErrNone(r);
			}
		else
			{
			r = numsettings.Remove(setting->iName.iId.iCat);
			test_KErrNone(r);
			r = numsettings.Insert(setting->iName.iId.iCat, value + 1);
			test_KErrNone(r);
			}
		}

	// 
	RHashMap<TUint32, TInt>::TIter catiter(numsettings);
	for (;;)
		{
		const TUint32* nextcat = catiter.NextKey();
		if (!nextcat)
			{
			break;
			}
		test.Printf(_L("Category %08x"), *nextcat);
		const TInt* v = numsettings.Find(*nextcat);
		test_NotNull(v);

		// Allocate memory for holding array of settings
		TElementId* elids;
		TSettingType* types;
		TUint16* lens;
		elids = (TElementId*) User::Alloc(*v * sizeof(TElementId));
		test_NotNull(elids);
		types = (TSettingType*) User::Alloc(*v * sizeof(TSettingType));
		test_NotNull(types);
		lens = (TUint16*) User::Alloc(*v * sizeof(TUint16));
		test_NotNull(lens);
		
		// Try all permutations of optional values
		TInt i;
		for (i = 0; i < 3; i++)
			{
			test.Printf(_L("."));
			Mem::Fill(elids, *v * sizeof(TElementId), 0xcc);
			Mem::Fill(types, *v * sizeof(TSettingType), 0xcc);
			Mem::Fill(lens, *v * sizeof(TUint16), 0xcc);
			TUint32 numfound;
			r = HcrSimTest.FindSettings(*nextcat,
				*v, numfound,
				elids,
				i & 0x1 ? types : NULL,
				i & 0x2 ? lens : NULL);
			numfound = r;
			test_Compare(0, <=, r);
			test_Equal(*v, r);
			

			// Check returned list of element ids
			TUint j;
			for (j = 0; j < numfound; j++)
				{
				// Find current element in the test array
				for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
					{
					if ((setting->iName.iId.iCat == *nextcat) && (setting->iName.iId.iKey == elids[j]))
						{
						break;
						}
					}
				test_Compare(setting,<,aRepository+aNumberOfSettings); // Fail if element not found
				switch (setting->iName.iType)
					{
					case ETypeInt32:
					case ETypeInt16:
					case ETypeInt8:
					case ETypeBool:
					case ETypeUInt32:
					case ETypeUInt16:
					case ETypeUInt8:
					case ETypeLinAddr:
						if (i & 0x1)
							{
							test_Equal(setting->iName.iType, types[j]);
							}
						if (i & 0x2)
							{
							test_Equal(0, lens[j]);
							}
						break;
						// Fall-through
					case ETypeBinData:
					case ETypeText8:
					case ETypeArrayInt32:
					case ETypeArrayUInt32:
					case ETypeInt64:
					case ETypeUInt64:
						if (i & 0x1)
							{
							test_Equal(setting->iName.iType, types[j]);
							}
						if (i & 0x2)
							{
							test_Equal(setting->iName.iLen, lens[j]);
							}
						break;
					default:
						test(EFalse);
					}
				}
			// Check all expected elements are in the returned list of element ids
			for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
				{
				if ((setting->iName.iId.iCat == *nextcat))
					{
					for (j = 0; j < numfound; j++)
						{
						if (elids[j] == setting->iName.iId.iKey)
							{
							break;
							}
						}
					test_Compare(j, <=, numfound);
					}
				}
			}
		User::Free(elids);
		User::Free(types);
		User::Free(lens);
		test.Printf(_L("\n"));
		}
	numsettings.Close();
	}

struct TTestFindSettingsPatternArgs
	{
	TUint32 iMask;
	TUint32 iPattern;
	};

const TTestFindSettingsPatternArgs KTestFindSettingsPatternArgs[] = {
//	 iMask	   iPattern
	{0x00000000, 0x00000000},
/*  {0xfffffff0, 0x00000000},
	{0xffffffff, 0x00000001},*/
};

void HcrSimFindSettingsPattern(SSettingC* aRepository, TUint aNumberOfSettings)
	{
	test.Next(_L("FindSettingsPattern"));
	TInt r;
	TUint i;

	// Allocate memory for holding array of settings
	TElementId* elids;
	TSettingType* types;
	TUint16* lens;
	elids = (TElementId*) User::Alloc(aNumberOfSettings * sizeof(TElementId));
	test_NotNull(elids);
	types = (TSettingType*) User::Alloc(aNumberOfSettings * sizeof(TSettingType));
	test_NotNull(types);
	lens = (TUint16*) User::Alloc(aNumberOfSettings * sizeof(TUint16));
	test_NotNull(lens);

	for (i = 0; i < sizeof(KTestFindSettingsPatternArgs) / sizeof(TTestFindSettingsPatternArgs); i++)
		{
		test.Printf(_L("iMask=0x%08x iPattern=0x%08x\n"),
			KTestFindSettingsPatternArgs[i].iMask,
			KTestFindSettingsPatternArgs[i].iPattern);

		// Test each category
		TUint j;
		for (j = 0; j < sizeof(KTestCategories) / sizeof(TCategoryUid); j++)
			{
			test.Printf(_L("Category 0x%08x: "), KTestCategories[j]);

			// Test all possible permutations of optional arguments
			TUint k;
			for (k = 0; k < 3; k++)
				{
				TUint32 numfound;
				// Actual API call
				r = HcrSimTest.FindSettings(
					KTestCategories[j],
					aNumberOfSettings,
					KTestFindSettingsPatternArgs[i].iMask,
					KTestFindSettingsPatternArgs[i].iPattern,
					numfound,
					elids,
					(k & 0x1 ? types : NULL),
					(k & 0x2 ? lens : NULL));
				test_Compare(0, <=, r);
				
				numfound = r;
			
				test.Printf(_L("%d match(es)\n"), r);

				// Check that all returned element ids satisfy the conditions
				TUint l;
				for (l = 0; l < numfound; l++)
					{
					test_Assert(
						(KTestFindSettingsPatternArgs[i].iMask & KTestFindSettingsPatternArgs[i].iPattern) ==
						(KTestFindSettingsPatternArgs[i].iMask & elids[l]), test.Printf(_L("!!%08x!!\n"), elids[l])
						);
					//Somehow the macro test_Compare consider TInt32 instead TUint32
					//as a result comparasion is done by this way:
					//RTEST: (0x0 (0) < 0x80000000 (-2147483648)) == EFalse at line 1038
					//althought 0x80000000 > 0, with the signed form this number will be
					//-2147483648.
					//test_Compare(KTestFindSettingsPatternArgs[i].iAtId, <=, elids[l]);
					}

				// Check that all elements that satisfy the conditions have been returned
				SSettingC* setting;
				TUint32 numsettings = 0;
				for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
					{
					if ((setting->iName.iId.iCat == KTestCategories[j])
						&& ((KTestFindSettingsPatternArgs[i].iMask & KTestFindSettingsPatternArgs[i].iPattern) ==
							(KTestFindSettingsPatternArgs[i].iMask & setting->iName.iId.iKey)))
						{
						for (l = 0; l < numfound; l++)
							{
							if (setting->iName.iId.iKey == elids[l])
								{
								break;
								}
							}
						test_Assert(l < numfound, test.Printf(_L("!!%08x!!\n"), elids[l]));

						// Check type and size returned
						switch (setting->iName.iType)
							{
							case ETypeInt32:
							case ETypeInt16:
							case ETypeInt8:
							case ETypeBool:
							case ETypeUInt32:
							case ETypeUInt16:
							case ETypeUInt8:
							case ETypeLinAddr:
								if (k & 0x1)
									{
									test_Equal(setting->iName.iType, types[l]);
									}
								if (k & 0x2)
									{
									test_Equal(0, lens[l]);
									}
								break;
								// Fall-through
							case ETypeBinData:
							case ETypeText8:
							case ETypeArrayInt32:
							case ETypeArrayUInt32:
							case ETypeInt64:
							case ETypeUInt64:
								if (k & 0x1)
									{
									test_Equal(setting->iName.iType, types[l]);
									}
								if (k & 0x2)
									{
									test_Equal(setting->iName.iLen, lens[l]);
									}
								break;
							default:
								test(EFalse);
							}
						numsettings++;
						}
					}
				test_Equal(numsettings, numfound);
				}
			}
		}
		
	// Free memory
	User::Free(elids);
	User::Free(types);
	User::Free(lens);
	}

void HcrSimApiNegative(const TInt aExpectedErrorCode, const TUint32 aCategory, const TUint32 aSettingId)
	{
	test.Next(_L("ApiNegative"));
	test.Printf(_L("Expected error: %d\nSetting (%08x, %08x)\n"), aExpectedErrorCode, aCategory, aSettingId);
	TSettingId id(aCategory, aSettingId);
	TInt r;
		{
		TInt32 val;
		r = HcrSimTest.GetInt(id, val);
		test_Equal(aExpectedErrorCode, r);
		}
		{
		TInt16 val;
		r = HcrSimTest.GetInt(id, val);
		test_Equal(aExpectedErrorCode, r);
		}
		{
		TInt8 val;
		r = HcrSimTest.GetInt(id, val);
		test_Equal(aExpectedErrorCode, r);
		}
		{
		TBool val;
		r = HcrSimTest.GetBool(id, val);
		test_Equal(aExpectedErrorCode, r);
		}
		{
		TUint32 val;
		r = HcrSimTest.GetUInt(id, val);
		test_Equal(aExpectedErrorCode, r);
		}
		{
		TUint16 val;
		r = HcrSimTest.GetUInt(id, val);
		test_Equal(aExpectedErrorCode, r);
		}
		{
		TUint8 val;
		r = HcrSimTest.GetUInt(id, val);
		test_Equal(aExpectedErrorCode, r);
		}
		{
		TLinAddr val;
		r = HcrSimTest.GetLinAddr(id, val);
		test_Equal(aExpectedErrorCode, r);
		}
		{
		TBuf8<KMaxSettingLength> dval;
		TUint8* pval;
		pval = (TUint8*) User::Alloc(KMaxSettingLength);
		test_NotNull(pval);
		//
		r = HcrSimTest.GetData(id, dval);
		test_Equal(aExpectedErrorCode, r);
		//
		TUint16 actuallength;
		r = HcrSimTest.GetData(id, KMaxSettingLength, pval, actuallength);
		test_Equal(aExpectedErrorCode, r);
		//
		User::Free(pval);
		}
		{
		TBuf8<KMaxSettingLength> dval;
		TText8* pval;
		pval = (TText8*) User::Alloc(KMaxSettingLength);
		test_NotNull(pval);
		//
		r = HcrSimTest.GetString(id, dval);
		test_Equal(aExpectedErrorCode, r);
		//
		TUint16 actuallength;
		r = HcrSimTest.GetString(id, KMaxSettingLength, pval, actuallength);
		test_Equal(aExpectedErrorCode, r);
		//
		User::Free(pval);
		}
		{
		TInt32* pval;
		pval = (TInt32*) User::Alloc(KMaxSettingLength);
		test_NotNull(pval);
		//
		TUint16 actuallength;
		r = HcrSimTest.GetArray(id, KMaxSettingLength, pval, actuallength);
		test_Equal(aExpectedErrorCode, r);
		//
		User::Free(pval);
		}
		{
		TUint32* pval;
		pval = (TUint32*) User::Alloc(KMaxSettingLength);
		test_NotNull(pval);
		//
		TUint16 actuallength;
		r = HcrSimTest.GetArray(id, KMaxSettingLength, pval, actuallength);
		test_Equal(aExpectedErrorCode, r);
		//
		User::Free(pval);
		}
		{
		TInt64 val;
		r = HcrSimTest.GetInt(id, val);
		test_Equal(aExpectedErrorCode, r);
		}
		{
		TUint64 val;
		r = HcrSimTest.GetUInt(id, val);
		test_Equal(aExpectedErrorCode, r);
		}

		{
		TSettingType type = ETypeUndefined;
		TUint16 len = 0;
		TUint32 numfound = 0;
		TElementId elid = 0;
		

		//
		r = HcrSimTest.GetTypeAndSize(id, type, len);
		test_Equal(aExpectedErrorCode, r);

		//
		r = HcrSimTest.FindNumSettingsInCategory(id.iCat);
		if (aExpectedErrorCode == KErrNotFound)
			{
			test_Equal(0, r);
			}
		
		//
		r = HcrSimTest.FindSettings(id.iCat, 1, numfound, &elid, &type, &len);
		if (aExpectedErrorCode == KErrNotFound)
			{
			test_Equal(0, r);
			}

		//
		r = HcrSimTest.FindSettings(id.iCat, 1, 0, 0, numfound, &elid, &type, &len);
		if (aExpectedErrorCode == KErrNotFound)
			{
			test_Equal(0, r);
			}
		
		}
		{
		SSettingId settingid;
		settingid.iCat = id.iCat;
		settingid.iKey = id.iKey;	
	
		TInt32 val;
		TInt err;
		TSettingType type;
		TInt i;

		for(i = 0; i < 4; ++i)
			{
			// test parameter combinations where aIds[], aValues[], aErrors[] are NULL
			r = HcrSimTest.GetWordSettings(i, (i==1)?NULL:&settingid, (i==2)?NULL:&val, &type, (i==3)?NULL:&err);
			if(r != KErrArgument)
				{
				test_Equal(aExpectedErrorCode, r);
				}
			}	
		}

	}

void HcrSimTestApiTests(SSettingC* aRepository, TUint aNumberOfSettings)
	{
	if (aRepository && aNumberOfSettings > 0)
		{
		HcrSimGetSettings(aRepository, aNumberOfSettings);
		HcrSimGetSettingsNegative(aRepository, aNumberOfSettings);
		HcrSimSettingProperties(aRepository, aNumberOfSettings);
		HcrSimMultipleGet(aRepository, aNumberOfSettings);
		HcrSimNumSettingsInCategory(aRepository, aNumberOfSettings);
		HcrSimFindSettingsCategory(aRepository, aNumberOfSettings);
		HcrSimFindSettingsPattern(aRepository, aNumberOfSettings);
		}

	HcrSimApiNegative(KErrNotFound, KTestInvalidCategory, KTestInvalidSettingId);
	HcrSimApiNegative(KErrNotFound, KTestInvalidCategory, 1);
	}

void HcrPslTests(const TDesC& aDriver)
	{
	test.Next(_L("PSL tests"));
	test.Start(_L("Load Device Driver"));
	test.Printf(_L("%S\n"), &aDriver);
	TInt r;
	r = User::LoadLogicalDevice(aDriver);
	if (r == KErrAlreadyExists)
		{
		test.Printf(_L("Unload Device Driver and load it again\n"));
		r = User::FreeLogicalDevice(aDriver);
		test_KErrNone(r);
		r = User::LoadLogicalDevice(aDriver);
		test_KErrNone(r);
		}
	else
		{
		test_KErrNone(r);
		}

	test.Next(_L("Open test channel"));
	r = HcrSimTest.Open(aDriver);
	test_KErrNone(r);

	test.Next(_L("Fail PSL object creation"));
	r = HcrSimTest.InitExtension(ETestVariantObjectCreateFail);
	test_Equal(KErrNoMemory, r);
	HcrSimApiNegative(KErrNotReady, 1, 1);

	test.Next(_L("Fail PSL initialisation"));
	r = HcrSimTest.InitExtension(ETestInitialisationFail);
	test_Equal(KErrBadPower, r); // the random error code used in the test PSL
	HcrSimApiNegative(KErrNotReady, 1, 1);

	test.Next(_L("PSL's GetCompiledRepositoryAddress negative tests"));
	r = HcrSimTest.InitExtension(ETestNullRepositoryKErrNone); // *** Null Repository but returns KErrNone
	test_Equal(KErrArgument, r);

	test.Next(_L("PSL's GetCompiledRepositoryAddress return wrong error code"));
	r = HcrSimTest.InitExtension(ETestBadErrorCode); // *** Null Repository but returns KErrNone
	test_Equal(KErrCommsParity, r);

	test.Next(_L("Close test channel and unload device driver"));
	HcrSimTest.Close();
	r = User::FreeLogicalDevice(aDriver);
	test_KErrNone(r);
	test.End();
	}

void HcrSimTests(const TDesC& aDriver)
	{
	test.Next(_L("HCR Simulator tests"));
	test.Start(_L("Load Device Driver"));
	test.Printf(_L("%S\n"), &aDriver);
	TInt r;
	r = User::LoadLogicalDevice(aDriver);
	if (r == KErrAlreadyExists)
		{
		test.Printf(_L("Unload Device Driver and load it again\n"));
		r = User::FreeLogicalDevice(aDriver);
		test_KErrNone(r);
		r = User::LoadLogicalDevice(aDriver);
		test_KErrNone(r);
		}
	else
		{
		test_KErrNone(r);
		}

	test.Next(_L("Open test channel"));
	r = HcrSimTest.Open(aDriver);
	test_KErrNone(r);
	HcrSimApiNegative(KErrNotReady, 1, 1);
	
	test.Next(_L("Initialise HCR"));
	r = HcrSimTest.InitExtension();
	test_KErrNone(r);
	
	test.Next(_L("Compiled"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	HcrSimTestApiTests(SettingsList, sizeof(SettingsList) / sizeof(SSettingC));
	test.End();

	test.Next(_L("Compiled+File"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestFileRepos, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	HcrSimTestApiTests(SettingsList2, sizeof(SettingsList2) / sizeof(SSettingC));
	test.End();
	
	test.Next(_L("Compiled+File+Nand"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestNandRepos, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	HcrSimTestApiTests(SettingsList3, sizeof(SettingsList3) / sizeof(SSettingC));
	test.End();

	test.Next(_L("Compiled+Nand"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	HcrSimTestApiTests(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC));
	test.End();

	test.Next(_L("Compiled+Empty+Nand"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestEmpty, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	HcrSimTestApiTests(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC));
	test.End();

	// Reload device driver without a compiled repository this time
	test.Next(_L("Reload Device Driver"));
	HcrSimTest.Close();
	r = User::FreeLogicalDevice(aDriver);
	test_KErrNone(r);
	r = User::LoadLogicalDevice(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.Open(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.InitExtension(ETestNullRepository); // *** The NULL Repository ***
	test_KErrNone(r);
	
	test.Next(_L("NULL+File"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	HcrSimTestApiTests(SettingsList7, sizeof(SettingsList7) / sizeof(SSettingC));
	test.End();
	
	test.Next(_L("NULL+File+Nand"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestNandRepos, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	HcrSimTestApiTests(SettingsList6, sizeof(SettingsList6) / sizeof(SSettingC));
	test.End();

	test.Next(_L("NULL+Nand"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	HcrSimTestApiTests(SettingsList5, sizeof(SettingsList5) / sizeof(SSettingC));
	test.End();

	test.Next(_L("Reload Device Driver"));
	HcrSimTest.Close();
	r = User::FreeLogicalDevice(aDriver);
	test_KErrNone(r);
	r = User::LoadLogicalDevice(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.Open(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.InitExtension(ETestEmptyRepository); // *** The Empty Repository ***
	test_KErrNone(r);

	test.Next(_L("Empty+Nand"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.SwitchRepository(KTestNandRepos, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	HcrSimTestApiTests(SettingsList5, sizeof(SettingsList5) / sizeof(SSettingC));
	test.End();

	test.Next(_L("Empty+File+Nand"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestFileRepos, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	HcrSimTestApiTests(SettingsList6, sizeof(SettingsList6) / sizeof(SSettingC));
	test.End();

	test.Next(_L("Empty+File"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	HcrSimTestApiTests(SettingsList7, sizeof(SettingsList7) / sizeof(SSettingC));
	test.End();

	test.Next(_L("No Repository (Empty)"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	HcrSimTestApiTests(NULL, 0);
	test.End();

	test.Next(_L("All Repositories Empty"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestEmpty, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.SwitchRepository(KTestEmpty, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	HcrSimTestApiTests(NULL, 0);
	test.End();

	test.Next(_L("Reload Device Driver"));
	HcrSimTest.Close();
	r = User::FreeLogicalDevice(aDriver);
	test_KErrNone(r);
	r = User::LoadLogicalDevice(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.Open(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.InitExtension(ETestIgnoreCoreImgRepository); // *** Ignore Core Image Repository ***
	test_KErrNone(r);

	test.Next(_L("Compiled+File(Ignored)+Nand")); // Should be same as Compiled+Nand
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestNandRepos, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	HcrSimTestApiTests(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC));
	test.End();

	test.Next(_L("Reload Device Driver (Corrupt1)"));
	HcrSimTest.Close();
	r = User::FreeLogicalDevice(aDriver);
	test_KErrNone(r);
	r = User::LoadLogicalDevice(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.Open(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.InitExtension(ETestCorruptRepository1); // *** Repository not ordered ***
#ifdef _DEBUG
	test_Equal(KErrCorrupt, r);
#else
	test_KErrNone(r);
#endif // _DEBUG

	test.Next(_L("Reload Device Driver (Corrupt2)"));
	HcrSimTest.Close();
	r = User::FreeLogicalDevice(aDriver);
	test_KErrNone(r);
	r = User::LoadLogicalDevice(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.Open(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.InitExtension(ETestCorruptRepository2); // *** Repository with duplicates ***
#ifdef _DEBUG
	test_Equal(KErrAlreadyExists, r);
#else
	test_KErrNone(r);
#endif // _DEBUG

	test.Next(_L("Reload Device Driver (NULL ordered list)"));
	HcrSimTest.Close();
	r = User::FreeLogicalDevice(aDriver);
	test_KErrNone(r);
	r = User::LoadLogicalDevice(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.Open(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.InitExtension(ETestNullOrderedList); // *** Repository where iOrderedSettingList==NULL ***
#ifdef _DEBUG
	test_Equal(KErrNotFound, r);
#else
	test_KErrNone(r);
#endif // _DEBUG

	test.Next(_L("Reload Device Driver (Default)"));
	HcrSimTest.Close();
	r = User::FreeLogicalDevice(aDriver);
	test_KErrNone(r);
	r = User::LoadLogicalDevice(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.Open(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.InitExtension(); // *** Default Repository ***
	test_KErrNone(r);

	test.Next(_L("Compiled+Corrupt1+Nand"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestCorrupt1, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.SwitchRepository(KTestNandRepos, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_Equal(KErrCorrupt, r);
	test.End();

	test.Next(_L("Compiled+Corrupt2+Nand"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestCorrupt2, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_Equal(KErrAlreadyExists, r);
	test.End();

	test.Next(_L("Compiled+File+Corrupt1"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestFileRepos, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.SwitchRepository(KTestCorrupt1, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_Equal(KErrCorrupt, r);
	test.End();

	test.Next(_L("Compiled+File+Corrupt2"));
	test.Start(_L("Initialisation"));
	r = HcrSimTest.SwitchRepository(KTestCorrupt2, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_Equal(KErrAlreadyExists, r);
	test.End();

	test.Next(_L("Close test channel and unload device driver"));
	HcrSimTest.Close();
	r = User::FreeLogicalDevice(aDriver);
	test_KErrNone(r);
	test.End();
	}

void RomHeaderTests()
	{
	test.Next(_L("Rom Header"));
#ifdef __WINS__
	test.Printf(_L("Not available on the emulator.\n"));
#else
	const TRomHeader* romheader = (TRomHeader*) UserSvr::RomHeaderAddress();
	test.Printf(_L("HCR File Address: %08x\n"), romheader->iHcrFileAddress);
	test(romheader->iHcrFileAddress);
	if (romheader->iPageableRomStart)
		{
		// If this is a paged ROM, HCR file must be in the unpaged area
		test_Compare(romheader->iRomBase + romheader->iPageableRomStart, >, romheader->iHcrFileAddress);
		}
#endif // __WINS__
	}

void HcrRealSettingDiscovery()
	{
	test.Next(_L("Setting Discovery"));
	TInt r;
	TCategoryUid cat;
	test.Printf(_L("Category Element  Type     Len  Value\n"));
	test.Printf(_L("--------------------------------------------------\n"));
	for (cat = KHCRUID_ALLOCATED_MIN; cat <= KHCRUID_ALLOCATED_MAX; cat++)
		{
		TInt nosettings;
		nosettings = HcrSimTest.FindNumSettingsInCategory(cat);
		test_Compare(0, <=, nosettings);
		if (nosettings > 0)
			{
			TUint32 numfound;
			TElementId* elids;
			TSettingType* types;
			TUint16* lens;
			elids = (TElementId*) User::Alloc(nosettings * sizeof(TElementId));
			test_NotNull(elids);
			types = (TSettingType*) User::Alloc(nosettings * sizeof(TSettingType));
			test_NotNull(types);
			lens = (TUint16*) User::Alloc(nosettings * sizeof(TUint16));
			test_NotNull(lens);
			r = HcrSimTest.FindSettings(cat, nosettings, numfound, elids, types, lens);
			test_Equal(nosettings, r);
			test_Equal(nosettings, numfound);
			TInt i;
			for (i = 0; i < nosettings; i++)
				{
				TSettingId id(cat, *(elids + i));
				test.Printf(_L("%08x %08x %08x %04x "), cat, *(elids + i), *(types + i), *(lens + i));
				switch (*(types + i))
					{
					case ETypeInt32:
						{
						TInt32 val;
						r = HcrSimTest.GetInt(id, val);
						test_KErrNone(r);
						test.Printf(_L("%08x"), val);
						break;
						}
					case ETypeInt16:
						{
						TInt16 val;
						r = HcrSimTest.GetInt(id, val);
						test_KErrNone(r);
						test.Printf(_L("%04x"), val);
						break;
						}
					case ETypeInt8:
						{
						TInt8 val;
						r = HcrSimTest.GetInt(id, val);
						test_KErrNone(r);
						test.Printf(_L("%02x"), val);
						break;
						}
					case ETypeBool:
						{
						TBool val;
						r = HcrSimTest.GetBool(id, val);
						test_KErrNone(r);
						test.Printf(_L("%b"), val ? 1 : 0);
						break;
						}
					case ETypeUInt32:
						{
						TUint32 val;
						r = HcrSimTest.GetUInt(id, val);
						test_KErrNone(r);
						test.Printf(_L("%08x"), val);
						break;
						}
					case ETypeUInt16:
						{
						TUint16 val;
						r = HcrSimTest.GetUInt(id, val);
						test_KErrNone(r);
						test.Printf(_L("%04x"), val);
						break;
						}
					case ETypeUInt8:
						{
						TUint8 val;
						r = HcrSimTest.GetUInt(id, val);
						test_KErrNone(r);
						test.Printf(_L("%02x"), val);
						break;
						}
					case ETypeLinAddr:
						{
						TLinAddr val;
						r = HcrSimTest.GetLinAddr(id, val);
						test_KErrNone(r);
						test.Printf(_L("%08x"), val);
						break;
						}
					case ETypeBinData:
						{
						TBuf8<KMaxSettingLength> dval;
						TUint8* pval;
						pval = (TUint8*) User::Alloc(*(lens + i));
						test_NotNull(pval);
						//
						r = HcrSimTest.GetData(id, dval);
						test_KErrNone(r);
						test_Equal(*(lens + i), dval.Length());
						//
						TUint16 actuallength;
						r = HcrSimTest.GetData(id, *(lens + i), pval, actuallength);
						test_KErrNone(r);
						test_Equal(*(lens + i), actuallength);
						//
						TInt j;
						for (j = 0; j < 6 && j < dval.Length(); j++)
							{
							test.Printf(_L("%02x "), dval[j]);
							}
							
						//
						User::Free(pval);
						break;
						}
					case ETypeText8:
						{
						TBuf8<KMaxSettingLength> dval;
						TText8* pval;
						pval = (TText8*) User::Alloc(*(lens + i));
						test_NotNull(pval);
						//
						r = HcrSimTest.GetString(id, dval);
						test_KErrNone(r);
						test_Equal(*(lens + i), dval.Length());
						//
						TUint16 actuallength;
						r = HcrSimTest.GetString(id, *(lens + i), pval, actuallength);
						test_KErrNone(r);
						test_Equal(*(lens + i), actuallength);
						//
						TInt j;
						for (j = 0; j < 15 && j < dval.Length(); j++)
							{
							test.Printf(_L("%c "), dval[j]);
							}
						//
						User::Free(pval);
						break;
						}
					case ETypeArrayInt32:
						{
						TInt32* pval;
						pval = (TInt32*) User::Alloc(*(lens + i));
						test_NotNull(pval);
						//
						TUint16 actuallength;
						r = HcrSimTest.GetArray(id, *(lens + i), pval, actuallength);
						test_KErrNone(r);
						//
						test_Equal(*(lens + i), actuallength);
						//
						TUint j;
						for (j = 0; j < 2 && j < actuallength / sizeof(TInt32); j++)
							{
							test.Printf(_L("%08x "), pval[0]);
							}
						//
						User::Free(pval);
						break;
						}
					case ETypeArrayUInt32:
						{
						TUint32* pval;
						pval = (TUint32*) User::Alloc(*(lens + i));
						test_NotNull(pval);
						//
						TUint16 actuallength;
						r = HcrSimTest.GetArray(id, *(lens + i), pval, actuallength);
						test_KErrNone(r);
						//
						TUint j;
						for (j = 0; j < 2 && j < actuallength / sizeof(TUint32); j++)
							{
							test.Printf(_L("%08x "), pval[0]);
							}
						//
						test_Equal(*(lens + i), actuallength);
						User::Free(pval);
						break;
						}
					case ETypeInt64:
						{
						TInt64 val;
						r = HcrSimTest.GetInt(id, val);
						test_KErrNone(r);
						test.Printf(_L("%016lx"), val);
						
						break;
						}
					case ETypeUInt64:
						{
						TUint64 val;
						r = HcrSimTest.GetUInt(id, val);
						test_KErrNone(r);
						test.Printf(_L("%016lx"), val);
						break;
						}
					default:
						test(EFalse);
					}
				test.Printf(_L("\n"));
				}
			User::Free(elids);
			User::Free(types);
			User::Free(lens);
			}
		}
	}
void HcrRealRetrieveKernelExtensionTestResults()
	{
	test.Next(_L("Retrieve kernel extension test results"));
	TInt r;
	TInt kextline;
	TInt kexterror;
	r = HcrSimTest.GetInitExtensionTestResults(kextline, kexterror);
	test_KErrNone(r);
	if (kextline == -1)
		{
		test.Printf(_L("Test not run\n"));
		}
	else if (kextline == 0)
		{
		test.Printf(_L("Test passed\n"));
		}
	else
		{
		test.Printf(_L("Test kernel extension error at line %d (error %d)\n"), kextline, kexterror);
		test(EFalse);
		}
	}

void HcrRealTests(const TDesC& aDriver)
	{
	test.Next(_L("HCR real tests"));
	test.Start(_L("Load LDD"));
	test.Printf(_L("%S\n"), &aDriver);
	TInt r;
	r = User::LoadLogicalDevice(aDriver);
	if (r == KErrNotFound)
		{
		test.Printf(_L("%S not found. Skipping tests.\n"), &aDriver);
		}
	else
		{
		if (r == KErrAlreadyExists)
			{
			test.Printf(_L("Unload Device Driver and load it again\n"));
			r = User::FreeLogicalDevice(aDriver);
			test_KErrNone(r);
			r = User::LoadLogicalDevice(aDriver);
			}
		test_KErrNone(r);
		r = HcrSimTest.Open(aDriver);
		test_KErrNone(r);
		//
		HcrRealRetrieveKernelExtensionTestResults();
		HcrRealSettingDiscovery();
		//
		test.Next(_L("Close LDD"));
		HcrSimTest.Close();
		r = User::FreeLogicalDevice(aDriver);
		test_KErrNone(r);
		}
	test.End();
	}

void HcrSimBenchmarkTests(const TDesC& aDriver)
	{
	test.Next(_L("Simulated HCR Benchmark"));
	test.Start(_L("Initialisation"));
	test.Printf(_L("%S\n"), &aDriver);
	TInt r;
	r = User::LoadLogicalDevice(aDriver);
	if (r == KErrAlreadyExists)
		{
		test.Printf(_L("Unload Device Driver and load it again\n"));
		r = User::FreeLogicalDevice(aDriver);
		test_KErrNone(r);
		r = User::LoadLogicalDevice(aDriver);
		test_KErrNone(r);
		}
	else
		{
		test_KErrNone(r);
		}
	r = HcrSimTest.Open(aDriver);
	test_KErrNone(r);
	r = HcrSimTest.InitExtension();
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);

	test.Next(_L("Get Setting"));
	// Timings in ms
	TUint32 int1 = 0;
	TUint32 int1000 = 0;
	TUint32 array1 = 0;
	TUint32 array1000 = 0;
	TUint32 des1 = 0;
	TUint32 des1000 = 0;
	TUint32 fns = 0;
	TUint32 fs = 0;
	TUint32 gts = 0;
	TUint32 gws = 0;
	_LIT(KTestBenchLine, "%-6d   %-6d   %-6d   %-6d   %-6d   %-6d   %-6d   %-6d   %-6d   %-6d\n");
	test.Printf(_L("HCR  Int1     Int1000  Arr1     Arr1000  Des1     Des1000  FNS      FS       GTS      GWS\n"));
	// Default configuration
	TSettingId idint1(1, 1);
	TSettingId idstring1(KTestCategories[2], 0x6000);
	test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1, int1));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1, array1));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1, des1));
	test.Printf(_L("C??  "));
	test.Printf(KTestBenchLine, int1, int1000, array1, array1000, des1, des1000, fns, fs, gts, gws);
	
	r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1, int1));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1, array1));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1, des1));
	test.Printf(_L("C__  "));
	test.Printf(KTestBenchLine, int1, int1000, array1, array1000, des1, des1000, fns, fs, gts, gws);
	//
	TSettingId idint1000(KTestBenchmarkCategoryId, 1000);
	TSettingId idstring1000(KTestBenchmarkCategoryId, 1001);
	r = HcrSimTest.SwitchRepository(KTestMegaLarge1, HCRInternal::ECoreRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1, int1));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1000, int1000));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1, array1));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1000, array1000));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1, des1));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1000, des1000));

	test_Equal(KTestBenchmarkNumberOfSettingsInCategory, HcrSimTest.BenchmarkFindNumSettingsInCategory(KTestBenchmarkCategoryId, fns));
	test_Equal(KTestBenchmarkNumberOfSettingsInCategory, HcrSimTest.BenchmarkFindSettings(KTestBenchmarkCategoryId, fs));
	test_KErrNone(HcrSimTest.BenchmarkGetTypeAndSize(idstring1000, gts));
	test_Equal(KTestBenchmarkNumberOfSettingsInCategory - 1, HcrSimTest.BenchmarkGetWordSettings(KTestBenchmarkCategoryId, gws));

	test.Printf(_L("CF_  "));
	test.Printf(KTestBenchLine, int1, int1000, array1, array1000, des1, des1000, fns, fs, gts, gws);
	//
	r = HcrSimTest.SwitchRepository(KTestMegaLarge2, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1, int1));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1000, int1000));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1, array1));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1000, array1000));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1, des1));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1000, des1000));

	test_Equal(KTestBenchmarkNumberOfSettingsInCategory, HcrSimTest.BenchmarkFindNumSettingsInCategory(KTestBenchmarkCategoryId, fns));
	test_Equal(KTestBenchmarkNumberOfSettingsInCategory, HcrSimTest.BenchmarkFindSettings(KTestBenchmarkCategoryId, fs));
	test_KErrNone(HcrSimTest.BenchmarkGetTypeAndSize(idstring1000, gts));
	test_Equal(KTestBenchmarkNumberOfSettingsInCategory - 1, HcrSimTest.BenchmarkGetWordSettings(KTestBenchmarkCategoryId, gws));

	test.Printf(_L("CFN  "));
	test.Printf(KTestBenchLine, int1, int1000, array1, array1000, des1, des1000, fns, fs, gts, gws);
	//
	r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos);
	test_KErrNone(r);
	r = HcrSimTest.CheckIntegrity();
	test_KErrNone(r);
	test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1, int1));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1000, int1000));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1, array1));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1000, array1000));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1, des1));
	test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1000, des1000));

	test_Equal(KTestBenchmarkNumberOfSettingsInCategory, HcrSimTest.BenchmarkFindNumSettingsInCategory(KTestBenchmarkCategoryId, fns));
	test_Equal(KTestBenchmarkNumberOfSettingsInCategory, HcrSimTest.BenchmarkFindSettings(KTestBenchmarkCategoryId, fs));
	test_KErrNone(HcrSimTest.BenchmarkGetTypeAndSize(idstring1000, gts));
	test_Equal(KTestBenchmarkNumberOfSettingsInCategory - 1, HcrSimTest.BenchmarkGetWordSettings(KTestBenchmarkCategoryId, gws));

	test.Printf(_L("C_N  "));
	test.Printf(KTestBenchLine, int1, int1000, array1, array1000, des1, des1000, fns, fs, gts, gws);

	test.Next(_L("Unload LDD"));
	HcrSimTest.Close();
	r = User::FreeLogicalDevice(aDriver);
	test_KErrNone(r);
	test.End();
	}

void HcrRealBenchmarkTests(const TDesC& aDriver)
	{
	TInt r;
	test.Next(_L("Real HCR Benchmark"));
	test.Start(_L("Initialisation"));
	test.Printf(_L("%S\n"), &aDriver);
	r = User::LoadLogicalDevice(aDriver);
	if (r == KErrNotFound)
		{
		test.Printf(_L("%S not found. Skipping tests.\n"), &aDriver);
		}
	else
		{
		if (r == KErrAlreadyExists)
			{
			test.Printf(_L("Unload Device Driver and load it again\n"));
			r = User::FreeLogicalDevice(aDriver);
			test_KErrNone(r);
			r = User::LoadLogicalDevice(aDriver);
			}
		test_KErrNone(r);
		r = HcrSimTest.Open(aDriver);
		test_KErrNone(r);
		//
		test.Next(_L("Close LDD"));
		HcrSimTest.Close();
		r = User::FreeLogicalDevice(aDriver);
		test_KErrNone(r);
		}
	test.End();
	}

GLDEF_C TInt E32Main()
	{
	__UHEAP_MARK;

	test.Title();
	test.Start(_L("HCR Test Suite"));
	
	
	
	//Order the the test lists in descend(the setting with the smallest
	//setting Id is first)
	TLinearOrder<SSettingC> order(CompareEntries);
	//Build the ordered ids arrays
	RArray<SSettingC> rSettingsList(sizeof(SSettingC), SettingsList,
			sizeof(SettingsList)/sizeof(SettingsList[0]));
	
	rSettingsList.Sort(order);
	
	RArray<SSettingC> rSettingsList2(sizeof(SSettingC), SettingsList2,
			sizeof(SettingsList2)/sizeof(SettingsList2[0]));
	rSettingsList2.Sort(order);

	RArray<SSettingC> rSettingsList3(sizeof(SSettingC), SettingsList3,
			sizeof(SettingsList3)/sizeof(SettingsList3[0]));
	rSettingsList3.Sort(order);

	RArray<SSettingC> rSettingsList4(sizeof(SSettingC), SettingsList4,
			sizeof(SettingsList4)/sizeof(SettingsList4[0]));
	rSettingsList4.Sort(order);

	RArray<SSettingC> rSettingsList5(sizeof(SSettingC), SettingsList5,
			sizeof(SettingsList5)/sizeof(SettingsList5[0]));
	rSettingsList5.Sort(order);

	RArray<SSettingC> rSettingsList6(sizeof(SSettingC), SettingsList6,
			sizeof(SettingsList6)/sizeof(SettingsList6[0]));
	rSettingsList6.Sort(order);

	RArray<SSettingC> rSettingsList7(sizeof(SSettingC), SettingsList7,
			sizeof(SettingsList7)/sizeof(SettingsList7[0]));
	rSettingsList7.Sort(order);


    //Functional API tests
	RomHeaderTests();
	HcrRealTests(KTestHcrRealOwn);
	HcrRealTests(KTestHcrRealClient);
	HcrPslTests(KTestHcrSimOwn);
	HcrPslTests(KTestHcrSimClient);
	HcrSimTests(KTestHcrSimOwn);
	HcrSimTests(KTestHcrSimClient);


	//Benchmark tests
	HcrSimBenchmarkTests(KTestHcrSimOwn);
	HcrSimBenchmarkTests(KTestHcrSimClient);
	HcrRealBenchmarkTests(KTestHcrRealOwn);
	HcrRealBenchmarkTests(KTestHcrRealClient);

	test.End();
	test.Close();

	__UHEAP_MARKEND;
	return KErrNone;
	}