We need a way to pass flags to rombuilds in Raptor via extension flm interfaces, so that the CPP pass
of the rom input files can be informed what toolchain we are building with and conditionally
include or exclude files depending on whether the toolchain could build them.
// 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, "");
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);
//
User::Free(valBuf);
}
if(setting->iName.iType == ETypeArrayInt32)
{
TInt32* valBuf;
TInt32* nullBuf = NULL;
valBuf = (TInt32*)User::Alloc(4*KMaxSettingLength);
test_NotNull(valBuf);
TUint16 actuallength;
TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);
//MaxLength = 0
r = HcrSimTest.GetArray(id, 0, valBuf, actuallength);
test_Equal(KErrArgument, r);
//buffer is not provided
r = HcrSimTest.GetArray(id, KMaxSettingLength, nullBuf, actuallength);
test_Equal(KErrArgument, r);
//neither buffer is not provided nor aMaxLen is not non-zero
r = HcrSimTest.GetArray(id, 0, nullBuf, actuallength);
test_Equal(KErrArgument, r);
User::Free(valBuf);
}
if(setting->iName.iType == ETypeArrayUInt32)
{
TUint32* valBuf;
TUint32* nullBuf = NULL;
valBuf = (TUint32*)User::Alloc(4*KMaxSettingLength);
test_NotNull(valBuf);
TUint16 actuallength;
TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);
//MaxLength = 0
r = HcrSimTest.GetArray(id, 0, valBuf, actuallength);
test_Equal(KErrArgument, r);
//buffer is not provided
r = HcrSimTest.GetArray(id, KMaxSettingLength,nullBuf, actuallength);
test_Equal(KErrArgument, r);
//neither buffer is not provided nor aMaxLen is not non-zero
r = HcrSimTest.GetArray(id, 0, nullBuf, actuallength);
test_Equal(KErrArgument, r);
User::Free(valBuf);
}
}
}
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);
#ifdef _DEBUG
test.Next(_L("Multiple Get on all settings, aIds[] is not ordered"));
nosettings = 0;
for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
{
if (setting->iName.iType < 0x00010000)
{
nosettings++;
}
}
test_Compare(2, <, 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);
//Swap two neigbours elements in the middle of the user array
HCR::SSettingId tmpSet;
TUint swappedIndex = (n >> 1) - 1;
//Make a copy of one of the swaped element
tmpSet.iCat = ids[swappedIndex].iCat;
tmpSet.iKey = ids[swappedIndex].iKey;
//Initialized that element with the values of the next one
ids[swappedIndex].iCat = ids[swappedIndex + 1].iCat;
ids[swappedIndex].iKey = ids[swappedIndex + 1].iKey;
//Write back data from the temproary element
ids[swappedIndex + 1].iCat = tmpSet.iCat;
ids[swappedIndex + 1].iKey = tmpSet.iKey;
r = HcrSimTest.GetWordSettings(nosettings, ids, vals, types, errs);
//HCR returns KErrArgument because ids array was not properly ordered
test_Equal(KErrArgument, r);
User::Free(ids);
User::Free(vals);
User::Free(types);
User::Free(errs);
#endif
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;
TInt maxNum;
// Try all permutations of optional values
TInt i;
for (i = 0; i < 3; i++)
{
test.Printf(_L("."));
TUint32 numfound;
//maxNum is equal:
//0 - 1, the total elements from the category
//1 - 1/2 of total number of elements from the category
//2 - 1 + 1/2 of total number of element from the category
if(i == 0)
maxNum = *v;
else if(i == 1)
maxNum = _FRACTION((*v), 2);
else
maxNum = *v + _FRACTION((*v), 2);
elids = (TElementId*) User::Alloc(maxNum * sizeof(TElementId));
test_NotNull(elids);
types = (TSettingType*) User::Alloc(maxNum * sizeof(TSettingType));
test_NotNull(types);
lens = (TUint16*) User::Alloc(maxNum * sizeof(TUint16));
test_NotNull(lens);
Mem::Fill(elids, maxNum * sizeof(TElementId), 0xcc);
Mem::Fill(types, maxNum * sizeof(TSettingType), 0xcc);
Mem::Fill(lens, maxNum * sizeof(TUint16), 0xcc);
r = HcrSimTest.FindSettings(*nextcat,
maxNum, elids,
i & 0x1 ? types : NULL,
i & 0x2 ? lens : NULL);
numfound = r;
test_Compare(0, <=, r);
if(i < 2)
{
//for 0 & 1 the number of settings returned must be equal maxNum
test_Equal(maxNum, r);
}
else
{
//for 2, it's equal the real number of settings
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;
TInt maxNum;
// 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);
}
}
// Hash map includes the number of settings of each category
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);
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);
TUint k;
for (k = 0; k < 3; k++)
{
TUint32 numfound;
// aMaxNum is less than the total number of settings in the
// category
//0 - all elements from the category are requested
//1 - 1/2 of total number of elements from the category
//2 - 1 + 1/2 of total number of element from the category
if(k == 0)
maxNum = *v;
else if(k == 1)
maxNum = _FRACTION((*v), 2);
else
maxNum = (*v) + _FRACTION((*v), 2);
elids = (TElementId*) User::Alloc(maxNum * sizeof(TElementId));
test_NotNull(elids);
types = (TSettingType*) User::Alloc(maxNum * sizeof(TSettingType));
test_NotNull(types);
lens = (TUint16*) User::Alloc(maxNum * sizeof(TUint16));
test_NotNull(lens);
// Actual API call
r = HcrSimTest.FindSettings(
*nextcat,
maxNum,
KTestFindSettingsPatternArgs[i].iMask,
KTestFindSettingsPatternArgs[i].iPattern,
elids,
(k & 0x1 ? types : NULL),
(k & 0x2 ? lens : NULL));
test_Compare(0, <=, r);
test_Compare(maxNum, >=, r);
numfound = r;
test.Printf(_L("%d match(es)\n"), r);
// Check that all returned element ids satisfy the conditions
TUint32 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;
//Flag indicates that the element is found
TBool fFlag = EFalse;
for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++)
{
if ((setting->iName.iId.iCat == *nextcat)
&& ((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])
{
fFlag = ETrue;
break;
}
}
if(fFlag)
{
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++;
fFlag = EFalse;
}
}
}
test_Equal(numsettings, numfound);
// Free memory
User::Free(elids);
User::Free(types);
User::Free(lens);
}
}
}
numsettings.Close();
}
void HcrSimFindSettingsCategoryNegative(SSettingC* aRepository, TUint aNumberOfSettings)
{
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;
//Iterator object of the number of elements in the category
RHashMap<TUint32, TInt>::TIter catiter(numsettings);
test.Next(_L("FindSettingsCategoryNegative invalid user parameters"));
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);
}
}
//
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);
test.Printf(_L("."));
Mem::Fill(elids, *v * sizeof(TElementId), 0xcc);
Mem::Fill(types, *v * sizeof(TSettingType), 0xcc);
Mem::Fill(lens, *v * sizeof(TUint16), 0xcc);
TInt i;
for (i = 0; i < 3; i++)
{
//Perform the following permutations:
// 0 - negative aMaxNum AND aElIds != NULL
// 1 - positive aMaxNum AND aElIds == NULL
// 2 - negative aMaxNum AND aElIds == NULL
switch(i)
{
case 0:
r = HcrSimTest.FindSettings(*nextcat,
(-1)*(*v), elids, types, lens);
test_Equal(KErrArgument, r);
break;
case 1:
r = HcrSimTest.FindSettings(*nextcat,
*v, NULL, types, lens);
test_Equal(KErrArgument, r);
break;
case 2:
r = HcrSimTest.FindSettings(*nextcat,
(-1)*(*v), NULL, types, lens);
test_Equal(KErrArgument, r);
break;
}
}
User::Free(elids);
User::Free(types);
User::Free(lens);
test.Printf(_L("\n"));
}
numsettings.Close();
}
void HcrSimFindSettingsPatternNegative(TUint aNumberOfSettings)
{
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);
test.Next(_L("FindSettingsPattern, invalid user parameters"));
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
TInt k;
for (k = 0; k < 3; k++)
{
//Perform the following permutations:
// 0 - negative aMaxNum AND aElIds != NULL
// 1 - positive aMaxNum AND aElIds == NULL
// 2 - negative aMaxNum AND aElIds == NULL
switch(k)
{
case 0:
// Actual API call
r = HcrSimTest.FindSettings(
KTestCategories[j],
(-1) * static_cast<TInt>(aNumberOfSettings),
KTestFindSettingsPatternArgs[i].iMask,
KTestFindSettingsPatternArgs[i].iPattern,
elids,
types, lens);
test_Equal(KErrArgument,r);
break;
case 1:
// Actual API call
r = HcrSimTest.FindSettings(
KTestCategories[j],
aNumberOfSettings,
KTestFindSettingsPatternArgs[i].iMask,
KTestFindSettingsPatternArgs[i].iPattern,
NULL,
types, lens);
test_Equal(KErrArgument,r);
break;
case 2:
// Actual API call
r = HcrSimTest.FindSettings(
KTestCategories[j],
(-1) * static_cast<TInt>(aNumberOfSettings),
KTestFindSettingsPatternArgs[i].iMask,
KTestFindSettingsPatternArgs[i].iPattern,
NULL,
types, lens);
test_Equal(KErrArgument,r);
break;
}
}
}
}
// Free memory
User::Free(elids);
User::Free(types);
User::Free(lens);
}
void HcrSimFindSettingsPatternMemAllocFails(TUint aNumberOfSettings)
{
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);
test.Next(_L("FindSettingsPattern, memory allocation failure"));
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]);
//Memory allocation fail test. By this code we simulate the memory
//allocation failure at place defined by allocFactor. The loop will
//continue until the next allocation is not failed. When we reached
//this point it means we've gone through all possible allocations in
//the tested method below.
TInt allocFactor = 1;
//Memory allocation fails
do
{
__KHEAP_MARK;
__KHEAP_SETFAIL(RAllocator::EFailNext, allocFactor);
r = HcrSimTest.FindSettings(
KTestCategories[j],
aNumberOfSettings,
KTestFindSettingsPatternArgs[i].iMask,
KTestFindSettingsPatternArgs[i].iPattern,
elids,
types, lens);
__KHEAP_MARKEND;
__KHEAP_RESET;
//Let's arrise the memory allocation failure at another place
allocFactor ++;
}while(r == KErrNoMemory);
}
}
// 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;
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);
}
else
{
test_Equal(aExpectedErrorCode, r);
}
//
r = HcrSimTest.FindSettings(id.iCat, 1, &elid, &type, &len);
if (aExpectedErrorCode == KErrNotFound)
{
test_Equal(0, r);
}
else
{
test_Equal(aExpectedErrorCode, r);
}
//
r = HcrSimTest.FindSettings(id.iCat, 1, 0, 0, &elid, &type, &len);
if (aExpectedErrorCode == KErrNotFound)
{
test_Equal(0, r);
}
else
{
test_Equal(aExpectedErrorCode, r);
}
}
{
SSettingId settingid;
settingid.iCat = id.iCat;
settingid.iKey = id.iKey;
TInt32 val;
TInt err;
TSettingType type;
TInt i;
for(i = 0; i < 5; ++i)
{
// test parameter combinations where aIds[], aValues[], aErrors[] are NULL
r = HcrSimTest.GetWordSettings((i==1)?0:1, (i==2)?NULL:&settingid, (i==3)?NULL:&val, &type, (i==4)?NULL:&err);
if (aExpectedErrorCode != KErrNotFound)
{
// HCR did not initialise properly - HCR will not bother checking validity of arguments
test_Equal(aExpectedErrorCode, r);
}
else if (i > 0)
{
// One of the arguments is invalid
test_Equal(KErrArgument, r);
}
else
{
// Arguments are fine but element does not exist
test_Equal(0, 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);
HcrSimFindSettingsCategoryNegative(aRepository, aNumberOfSettings);
HcrSimFindSettingsPatternNegative(aNumberOfSettings);
if(gHcrThread == KSimOwnThread)
HcrSimFindSettingsPatternMemAllocFails(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);
//Initialize static variable with the right HCR client type
if(aDriver.Compare(KTestHcrSimOwn) == 0)
gHcrThread = KSimOwnThread;
else if(aDriver.Compare(KTestHcrSimClient) == 0)
gHcrThread = KSimClientThread;
else
test(EFalse);
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("Empty+File+Empty"));
test.Start(_L("Initialisation"));
r = HcrSimTest.SwitchRepository(KTestEmpty, 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.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos);
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)
{
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, elids, types, lens);
test_Equal(nosettings, r);
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();
// Initialize static variable with the right HCR client type
if(aDriver.Compare(KTestHcrRealOwn) == 0)
gHcrThread = KSimOwnThread;
else if(aDriver.Compare(KTestHcrRealClient) == 0)
gHcrThread = KSimClientThread;
else
test(EFalse);
//
TBool smr;
TBool smrrep;
r = HcrSimTest.HasRepositoryInSmr(smr, smrrep);
test_KErrNone(r);
if (smrrep)
{
// File + NAND
HcrSimTestApiTests(SettingsList6, sizeof(SettingsList6) / sizeof(SSettingC));
}
else
{
// File
HcrSimTestApiTests(SettingsList7, sizeof(SettingsList7) / sizeof(SSettingC));
}
//
test.Next(_L("Close LDD"));
HcrSimTest.Close();
r = User::FreeLogicalDevice(aDriver);
test_KErrNone(r);
}
test.End();
}
void HcrCatRecodsExampleTest(const TDesC& aDriver)
{
using namespace HCR;
test.Start(_L("HCR Record Structured Category Test"));
test.Next(_L("Load HCR Test driver"));
test.Printf(_L("%S\n"), &aDriver);
TInt r;
_LIT8(KTestCatRecordsRepos, "filerepos_cds.dat");
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("Initialise HCR"));
//r = HcrSimTest.InitExtension();
// *** The NULL Repository ***
r = HcrSimTest.InitExtension(ETestNullRepository);
test_KErrNone(r);
test.Next(_L("Load Test File repository"));
r = HcrSimTest.SwitchRepository(KTestCatRecordsRepos, HCRInternal::ECoreRepos);
test_KErrNone(r);
r = HcrSimTest.CheckIntegrity();
test_KErrNone(r);
struct TAccelCaps
{
TUint32 iManufactureId;
TUint16 iDeviceId;
char* iDevName;
TUint16 iDataRate;
TUint16 iResolution;
TUint16 iScale;
};
const TInt KCapsField_Manufacturer = 1;
const TInt KCapsField_Device = 2;
const TInt KCapsField_Name = 3;
const TInt KCapsField_DataRate = 4;
const TInt KCapsField_Resolution = 5;
const TInt KCapsField_Scale = 6;
const TInt KMaxNumAccelerateDevices = 2;
const TInt KNumElementsInRow = 6;
const TInt KKiSemiIndex = 0;
const TInt KSpecCo4gIndex = 1;
char KKiSemiIncDevName[] = "KI Semi Inc 8g Accelerometer";
const TUint16 KKiSemiIncDevNameLength = sizeof(KKiSemiIncDevName) - 1;
char KSpecCo4gDevName[] = "SPE Co 4g Accelerometer";
const TUint16 KSpecCo4gDevNameLength = sizeof(KSpecCo4gDevName) - 1;
TAccelCaps* capsStructs = new TAccelCaps[KMaxNumAccelerateDevices];
test_NotNull(capsStructs);
//Initialisation with the sample data
//KI SemiInc 8g
capsStructs[KKiSemiIndex].iManufactureId = 0x12003335;
capsStructs[KKiSemiIndex].iDeviceId = 0x2001;
capsStructs[KKiSemiIndex].iDevName = KKiSemiIncDevName;
capsStructs[KKiSemiIndex].iDataRate = 20;
capsStructs[KKiSemiIndex].iResolution = 8;
capsStructs[KKiSemiIndex].iScale = 8;
//SPE Co 4g
capsStructs[KSpecCo4gIndex].iManufactureId = 0x72103301;
capsStructs[KSpecCo4gIndex].iDeviceId = 0x0012;
capsStructs[KSpecCo4gIndex].iDevName = KSpecCo4gDevName;
capsStructs[KSpecCo4gIndex].iDataRate = 50;
capsStructs[KSpecCo4gIndex].iResolution = 16;
capsStructs[KSpecCo4gIndex].iScale = 4;
//Setting the value
TUint32 mask = 0x0000ffff;
const TUint32 KKiSemiPattern = 0x00010000u;
const TUint32 KSpecCo4gPattern = 0x00020000u;
const HCR::TCategoryUid category = 0x00000001u;
//SettingId container, it's used further down in the retrieve operations
HCR::TSettingId setId(category,0);
//Test Repository elements Ids data
HCR::SSettingId repIds[KMaxNumAccelerateDevices][KNumElementsInRow] =
{
{
{0x01, 65537}, {0x01, 65538}, {0x01, 65539},
{0x01, 65540}, {0x01, 65541}, {0x01, 65542}
},
{
{0x01, 131073}, {0x01, 131074}, {0x01, 131075},
{0x01, 131076}, {0x01, 131077}, {0x01, 131078}
}
};
HCR::TElementId* ids = new TElementId[KNumElementsInRow];
test_NotNull(ids);
HCR::TSettingType* types = new TSettingType[KNumElementsInRow];
test_NotNull(types);
TUint16* lengths = new TUint16[KNumElementsInRow];
test_NotNull(lengths);
//------------------------------------------------------------------
//Retrieve "ManufactureId" (column request) values for all devices
//------------------------------------------------------------------
r = HcrSimTest.FindSettings(category, KMaxNumAccelerateDevices, mask,
KCapsField_Manufacturer, ids, types, lengths);
//Assert against the error
test_Compare(r,>=,0);
//Check the number of elements
test_Equal(KMaxNumAccelerateDevices, r);
// Check the ids, lengths and types
test_Equal(repIds[KKiSemiIndex][KCapsField_Manufacturer - 1].iKey, ids[KKiSemiIndex]);
test_Equal(HCR::ETypeUInt32, types[KKiSemiIndex]);
test_Equal(0,lengths[KKiSemiIndex]);
// Check the ids, lengths and types
test_Equal(repIds[KSpecCo4gIndex][KCapsField_Manufacturer - 1].iKey, ids[KSpecCo4gIndex]);
test_Equal(HCR::ETypeUInt32, types[KSpecCo4gIndex]);
test_Equal(0,lengths[KSpecCo4gIndex]);
//----------------------------
//Get all ManufactureId values
//----------------------------
TUint32 manufId;
//KiSemi
setId.iKey = ids[KKiSemiIndex];
r = HcrSimTest.GetUInt(setId, manufId);
test_KErrNone(r);
test_Equal(capsStructs[KKiSemiIndex].iManufactureId, manufId);
//SpecCo
setId.iKey = ids[KSpecCo4gIndex];
r = HcrSimTest.GetUInt(setId, manufId);
test_KErrNone(r);
test_Equal(capsStructs[KSpecCo4gIndex].iManufactureId, manufId);
//------------------------------------------------------------------
//Retrieve "DeviceId" (column request) values for all devices
//------------------------------------------------------------------
r = HcrSimTest.FindSettings(category, KMaxNumAccelerateDevices, mask,
KCapsField_Device, ids, types, lengths);
//Assert against the error
test_Compare(r,>=,0);
//Check the number of elements
test_Equal(KMaxNumAccelerateDevices, r);
// Check the ids, lengths and types
test_Equal(repIds[KKiSemiIndex][KCapsField_Device - 1].iKey, ids[KKiSemiIndex]);
test_Equal(HCR::ETypeUInt16, types[KKiSemiIndex]);
test_Equal(0,lengths[KKiSemiIndex]);
// Check the ids, lengths and types
test_Equal(repIds[KSpecCo4gIndex][KCapsField_Device - 1].iKey, ids[KSpecCo4gIndex]);
test_Equal(HCR::ETypeUInt16, types[KSpecCo4gIndex]);
test_Equal(0,lengths[KSpecCo4gIndex]);
//----------------------------
//Get all DeviceId values
//----------------------------
TUint16 devId;
//KiSemi
setId.iKey = ids[KKiSemiIndex];
r = HcrSimTest.GetUInt(setId, devId);
test_KErrNone(r);
test_Equal(capsStructs[KKiSemiIndex].iDeviceId, devId);
//SpecCo
setId.iKey = ids[KSpecCo4gIndex];
r = HcrSimTest.GetUInt(setId, devId);
test_KErrNone(r);
test_Equal(capsStructs[KSpecCo4gIndex].iDeviceId, devId);
//------------------------------------------------------------------
//Retrieve "DeviceName" (column request) values for all devices
//------------------------------------------------------------------
r = HcrSimTest.FindSettings(category, KMaxNumAccelerateDevices, mask,
KCapsField_Name, ids, types, lengths);
//Assert against the error
test_Compare(r,>=,0);
//Check the number of elements
test_Equal(KMaxNumAccelerateDevices, r);
// Check the ids, lengths and types
test_Equal(repIds[KKiSemiIndex][KCapsField_Name - 1].iKey, ids[KKiSemiIndex]);
test_Equal(HCR::ETypeText8, types[KKiSemiIndex]);
test_Equal(KKiSemiIncDevNameLength,lengths[KKiSemiIndex]);
// Check the ids, lengths and types
test_Equal(repIds[KSpecCo4gIndex][KCapsField_Name - 1].iKey, ids[KSpecCo4gIndex]);
test_Equal(HCR::ETypeText8, types[KSpecCo4gIndex]);
test_Equal(KSpecCo4gDevNameLength,lengths[KSpecCo4gIndex]);
//----------------------------
//Get all DeviceName values
//----------------------------
TUint16 len;
//KiSemi
TText8* nameKiSemi = new TText8[KKiSemiIncDevNameLength];
test_NotNull(nameKiSemi);
setId.iKey = ids[KKiSemiIndex];
r = HcrSimTest.GetString(setId, KKiSemiIncDevNameLength,
nameKiSemi, len);
test_KErrNone(r);
r = memcompare((unsigned char*)capsStructs[KKiSemiIndex].iDevName, (int)KKiSemiIncDevNameLength,
nameKiSemi, (int)KKiSemiIncDevNameLength);
test_KErrNone(r);
//SpecCo
TText8* nameSpecCo = new TText8[KSpecCo4gDevNameLength];
test_NotNull(nameSpecCo);
setId.iKey = ids[KSpecCo4gIndex];
r = HcrSimTest.GetString(setId, KSpecCo4gDevNameLength,
nameSpecCo, len);
test_KErrNone(r);
r = memcompare((unsigned char*)capsStructs[KSpecCo4gIndex].iDevName,
(int)KSpecCo4gDevNameLength, nameSpecCo, (int)KSpecCo4gDevNameLength);
test_KErrNone(r);
//------------------------------------------------------------------
//Retrieve "DataRate" (column request) values for all devices
//------------------------------------------------------------------
r = HcrSimTest.FindSettings(category, KMaxNumAccelerateDevices, mask,
KCapsField_DataRate, ids, types, lengths);
//Assert against the error
test_Compare(r,>=,0);
//Check the number of elements
test_Equal(KMaxNumAccelerateDevices, r);
// Check the ids, lengths and types
test_Equal(repIds[KKiSemiIndex][KCapsField_DataRate - 1].iKey, ids[KKiSemiIndex]);
test_Equal(HCR::ETypeUInt16, types[KKiSemiIndex]);
test_Equal(0,lengths[KKiSemiIndex]);
// Check the ids, lengths and types
test_Equal(repIds[KSpecCo4gIndex][KCapsField_DataRate - 1].iKey, ids[KSpecCo4gIndex]);
test_Equal(HCR::ETypeUInt16, types[KSpecCo4gIndex]);
test_Equal(0,lengths[KSpecCo4gIndex]);
//----------------------------
//Get all DataRate values
//----------------------------
TUint16 dataRate;
//KiSemi
setId.iKey = ids[KKiSemiIndex];
r = HcrSimTest.GetUInt(setId, dataRate);
test_KErrNone(r);
test_Equal(capsStructs[KKiSemiIndex].iDataRate, dataRate);
//SpecCo
setId.iKey = ids[KSpecCo4gIndex];
r = HcrSimTest.GetUInt(setId, dataRate);
test_KErrNone(r);
test_Equal(capsStructs[KSpecCo4gIndex].iDataRate, dataRate);
//------------------------------------------------------------------
//Retrieve "Resolution" (column request) values for all devices
//------------------------------------------------------------------
r = HcrSimTest.FindSettings(category, KMaxNumAccelerateDevices, mask,
KCapsField_Resolution, ids, types, lengths);
//Assert against the error
test_Compare(r,>=,0);
//Check the number of elements
test_Equal(KMaxNumAccelerateDevices, r);
// Check the ids, lengths and types
test_Equal(repIds[KKiSemiIndex][KCapsField_Resolution - 1].iKey, ids[KKiSemiIndex]);
test_Equal(HCR::ETypeUInt16, types[KKiSemiIndex]);
test_Equal(0,lengths[KKiSemiIndex]);
// Check the ids, lengths and types
test_Equal(repIds[KSpecCo4gIndex][KCapsField_Resolution - 1].iKey, ids[KSpecCo4gIndex]);
test_Equal(HCR::ETypeUInt16, types[KSpecCo4gIndex]);
test_Equal(0,lengths[KSpecCo4gIndex]);
//----------------------------
//Get all "Resolution" values
//----------------------------
TUint16 resolution;
//KiSemi
setId.iKey = ids[KKiSemiIndex];
r = HcrSimTest.GetUInt(setId, resolution);
test_KErrNone(r);
test_Equal(capsStructs[KKiSemiIndex].iResolution, resolution);
//SpecCo
setId.iKey = ids[KSpecCo4gIndex];
r = HcrSimTest.GetUInt(setId, resolution);
test_KErrNone(r);
test_Equal(capsStructs[KSpecCo4gIndex].iResolution, resolution);
//------------------------------------------------------------------
//Retrieve "Scale" (column request) values for all devices
//------------------------------------------------------------------
r = HcrSimTest.FindSettings(category, KMaxNumAccelerateDevices, mask,
KCapsField_Scale, ids, types, lengths);
//Assert against the error
test_Compare(r,>=,0);
//Check the number of elements
test_Equal(KMaxNumAccelerateDevices, r);
// Check the ids, lengths and types
test_Equal(repIds[KKiSemiIndex][KCapsField_Scale - 1].iKey, ids[KKiSemiIndex]);
test_Equal(HCR::ETypeUInt16, types[KKiSemiIndex]);
test_Equal(0,lengths[KKiSemiIndex]);
// Check the ids, lengths and types
test_Equal(repIds[KSpecCo4gIndex][KCapsField_Scale - 1].iKey, ids[KSpecCo4gIndex]);
test_Equal(HCR::ETypeUInt16, types[KSpecCo4gIndex]);
test_Equal(0,lengths[KSpecCo4gIndex]);
//----------------------------
//Get all "Scale" values
//----------------------------
TUint16 scale;
//KiSemi
setId.iKey = ids[KKiSemiIndex];
r = HcrSimTest.GetUInt(setId, scale);
test_KErrNone(r);
test_Equal(capsStructs[KKiSemiIndex].iScale, scale);
//SpecCo
setId.iKey = ids[KSpecCo4gIndex];
r = HcrSimTest.GetUInt(setId, scale);
test_KErrNone(r);
test_Equal(capsStructs[KSpecCo4gIndex].iScale, scale);
//-----------------------------------------------------------------------
//Read a complete row data for the single device
//-----------------------------------------------------------------------
mask = 0xffff0000; //retrive a row
//------------------------
//KiSemi
//------------------------
r = HcrSimTest.FindSettings(category, KNumElementsInRow, mask,
KKiSemiPattern, ids, types, lengths);
//Assert against the error
test_Compare(r,>=,0);
//Assert the number of found elements
test_Equal(KNumElementsInRow, r);
//Check the ManufactureId
setId.iKey = ids[KCapsField_Manufacturer-1];
r = HcrSimTest.GetUInt(setId, manufId);
test_KErrNone(r);
test_Equal(capsStructs[KKiSemiIndex].iManufactureId, manufId);
//Check the DeviceId
setId.iKey = ids[KCapsField_Device-1];
r = HcrSimTest.GetUInt(setId, devId);
test_KErrNone(r);
test_Equal(capsStructs[KKiSemiIndex].iDeviceId, devId);
//Check the DeviceName
setId.iKey = ids[KCapsField_Name-1];
r = HcrSimTest.GetString(setId, KKiSemiIncDevNameLength,
nameKiSemi, len);
test_KErrNone(r);
r = memcompare((unsigned char*)capsStructs[KKiSemiIndex].iDevName,
(int)KKiSemiIncDevNameLength, nameKiSemi, (int)KKiSemiIncDevNameLength);
test_KErrNone(r);
//Check the DataRate
setId.iKey = ids[KCapsField_DataRate-1];
r = HcrSimTest.GetUInt(setId, dataRate);
test_KErrNone(r);
test_Equal(capsStructs[KKiSemiIndex].iDataRate, dataRate);
//Check the Resolution
setId.iKey = ids[KCapsField_Resolution-1];
r = HcrSimTest.GetUInt(setId, resolution);
test_KErrNone(r);
test_Equal(capsStructs[KKiSemiIndex].iResolution, resolution);
//------------------------
//SpecCo
//------------------------
r = HcrSimTest.FindSettings(category, KNumElementsInRow, mask,
KSpecCo4gPattern, ids, types, lengths);
//Assert against the error
test_Compare(r,>=,0);
//Assert the number of found elements
test_Equal(KNumElementsInRow, r);
//Check the ManufactureId
setId.iKey = ids[KCapsField_Manufacturer-1];
r = HcrSimTest.GetUInt(setId, manufId);
test_KErrNone(r);
test_Equal(capsStructs[KSpecCo4gIndex].iManufactureId, manufId);
//Check the DeviceId
setId.iKey = ids[KCapsField_Device-1];
r = HcrSimTest.GetUInt(setId, devId);
test_KErrNone(r);
test_Equal(capsStructs[KSpecCo4gIndex].iDeviceId, devId);
//Check the DeviceName
setId.iKey = ids[KCapsField_Name-1];
r = HcrSimTest.GetString(setId, KSpecCo4gDevNameLength,
nameSpecCo, len);
test_KErrNone(r);
r = memcompare((unsigned char*)capsStructs[KSpecCo4gIndex].iDevName,
(int)KSpecCo4gDevNameLength, nameSpecCo, (int)KSpecCo4gDevNameLength);
test_KErrNone(r);
//Check the DataRate
setId.iKey = ids[KCapsField_DataRate-1];
r = HcrSimTest.GetUInt(setId, dataRate);
test_KErrNone(r);
test_Equal(capsStructs[KSpecCo4gIndex].iDataRate, dataRate);
//Check the Resolution
setId.iKey = ids[KCapsField_Resolution-1];
r = HcrSimTest.GetUInt(setId, resolution);
test_KErrNone(r);
test_Equal(capsStructs[KSpecCo4gIndex].iResolution, resolution);
//Deallocate allocated resources
delete[] ids;
delete[] types;
delete[] lengths;
delete[] nameKiSemi;
delete[] nameSpecCo;
delete[] capsStructs;
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 test
RomHeaderTests();
HcrRealTests(KTestHcrRealOwn);
HcrRealTests(KTestHcrRealClient);
HcrPslTests(KTestHcrSimOwn);
HcrPslTests(KTestHcrSimClient);
HcrSimTests(KTestHcrSimOwn);
HcrSimTests(KTestHcrSimClient);
HcrCatRecodsExampleTest(KTestHcrSimOwn);
HcrCatRecodsExampleTest(KTestHcrSimClient);
//Benchmark tests
HcrSimBenchmarkTests(KTestHcrSimOwn);
HcrSimBenchmarkTests(KTestHcrSimClient);
HcrRealBenchmarkTests(KTestHcrRealOwn);
HcrRealBenchmarkTests(KTestHcrRealClient);
test.End();
test.Close();
__UHEAP_MARKEND;
return KErrNone;
}