Fix for bug 2283 (RVCT 4.0 support is missing from PDK 3.0.h)
Have multiple extension sections in the bld.inf, one for each version
of the compiler. The RVCT version building the tools will build the
runtime libraries for its version, but make sure we extract all the other
versions from zip archives. Also add the archive for RVCT4.
// 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;
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();
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);
}
}
}
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;
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 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);
//Benchmark tests
HcrSimBenchmarkTests(KTestHcrSimOwn);
HcrSimBenchmarkTests(KTestHcrSimClient);
HcrRealBenchmarkTests(KTestHcrRealOwn);
HcrRealBenchmarkTests(KTestHcrRealClient);
test.End();
test.Close();
__UHEAP_MARKEND;
return KErrNone;
}