// Copyright (c) 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:
// e32test/hcr/d_hcrsim.cpp
//
#include "d_hcrsim.h"
#include <kernel/kernel.h>
#include <plat_priv.h>
#include "hcr_debug.h"
#include "hcr_uids.h"
#ifdef HCRTEST_USERSIDE_INTERFACE
#include "d_hcrsim_testdata.h"
#endif // HCRTEST_USERSIDE_INTERFACE
#define TEST(a) CheckPoint(a, __LINE__)
#define TEST_KERRNONE(a) CheckPointError(a, __LINE__)
#ifndef HCRTEST_USERSIDE_INTERFACE
TInt InitExtension();
extern TUint32 PslConfigurationFlags;
#endif // HCRTEST_USERSIDE_INTERFACE
#ifdef HCRTEST_CLIENT_THREAD
#define TEST_ENTERCS() NKern::ThreadEnterCS()
#define TEST_LEAVECS() NKern::ThreadLeaveCS()
#define TEST_MEMGET(s, d, l) kumemget(d, s, l)
#define TEST_MEMPUT(d, s, l) kumemput(d, s, l)
#define TEST_DESGET(s, d) Kern::KUDesGet(d, *(TDes8*) s)
#define TEST_DESPUT(d, s) Kern::KUDesPut(*(TDes8*) d, s)
#else
#define TEST_ENTERCS()
#define TEST_LEAVECS()
#define TEST_MEMGET(s, d, l) Kern::ThreadRawRead(iClient, s, d, l)
#define TEST_MEMPUT(d, s, l) Kern::ThreadRawWrite(iClient, d, s, l)
#define TEST_DESGET(s, d) Kern::ThreadDesRead(iClient, s, d, 0)
#define TEST_DESPUT(d, s) Kern::ThreadDesWrite(iClient, d, s, 0)
#endif // HCRTEST_CLIENT_THREAD
// Test results for the Kernel Extension initialisation routine
TInt TestKernExtensionTestLine = -1;
TInt TestKernExtensionTestError = -1;
const TUint KTestBenchmarkIterations = 10000;
const TUint KTestGetMultipleBenchmarkIterations = 100;
class DHcrSimTestDrvFactory : public DLogicalDevice
{
public:
DHcrSimTestDrvFactory();
~DHcrSimTestDrvFactory();
virtual TInt Install();
virtual void GetCaps(TDes8& aDes) const;
virtual TInt Create(DLogicalChannelBase*& aChannel);
public:
#ifndef HCRTEST_CLIENT_THREAD
TDynamicDfcQue* iDfcQ;
#endif
};
#ifdef HCRTEST_CLIENT_THREAD
class DHcrSimTestDrvChannel : public DLogicalChannelBase
#else
class DHcrSimTestDrvChannel : public DLogicalChannel
#endif
{
public:
DHcrSimTestDrvChannel();
~DHcrSimTestDrvChannel();
// Inherited from DLogicalChannel
virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
#ifdef HCRTEST_CLIENT_THREAD
// Inherited from DLogicalChannelBase: process all DoControl in the user's context
virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2);
#else
TInt DoControl(TInt aReqNo, TAny* a1, TAny* a2);
virtual void HandleMsg(TMessageBase* aMsg);
public:
DThread* iClient;
#endif // HCRTEST_CLIENT_THREAD
};
void CheckPoint(TInt aCondition, TInt aLine)
{
if (!aCondition)
{
Kern::Printf("Device driver test failed (line %d)", aLine);
}
}
void CheckPointError(TInt aErrorCode, TInt aLine)
{
if (aErrorCode != KErrNone)
{
Kern::Printf("Device driver error %d (line %d)", aErrorCode, aLine);
}
}
void HasRepositoryInSmr(TBool& aHasSmr, TBool& aHasSmrHcr)
{
aHasSmr = EFalse;
aHasSmrHcr = EFalse;
// Note: the SMR feature by which we obtain the address of the override
// repository is only supported in the ARM bootstrap, not X86 or WINS so
// this test code needs conditional compilation.
#if !defined(__WINS__) && !defined(__X86__)
const TSuperPage& superpage = Kern::SuperPage();
TUint32* smrib = (TUint32*) superpage.iSmrData;
SSmrBank* smrbank = (SSmrBank*) smrib;
if((smrib != NULL) && (smrib != (TUint32*)KSuperPageAddressFieldUndefined))
{
aHasSmr = ETrue;
while (smrbank->iBase)
{
if (smrbank->iPayloadUID == KHCRUID_SMRPayloadUID)
{
// We have a HCR repository - assuming it is the test one...
aHasSmrHcr = ETrue;
break;
}
++smrbank;
}
}
#endif // !__WINS__ && !__X86__
}
#ifdef HCRTEST_USERSIDE_INTERFACE
#define KEXT_TESTKERRNONE(_r) \
{ \
TInt _s = _r; \
if ((_s) && !TestKernExtensionTestLine) \
{ \
TestKernExtensionTestError = (_r); \
TestKernExtensionTestLine = __LINE__; \
} \
}
#define KEXT_TEST(_r) \
{ \
if (!(_r) && !TestKernExtensionTestLine) \
{ \
TestKernExtensionTestError = 1; \
TestKernExtensionTestLine = __LINE__; \
} \
}
void KextInitTests()
{
TInt r;
// Get last Setting in Reference Compiled Repository
TUint32 value1;
TSettingId setting1(0xFFFFFFFF, 0xFFFFFFFF);
r = GetUInt(setting1, value1);
KEXT_TESTKERRNONE(r);
KEXT_TEST(value1==0x4C415354); // 'L', 'A', 'S', 'T'
// Determine what test repositories the HCR has loaded
// Make sure we have the file repository
const TRomHeader& romheader = Epoc::RomHeader();
KEXT_TEST(romheader.iHcrFileAddress != NULL); // Assuming this is the test repository (hcr.dat)
// Find the nand repository
TBool smr;
TBool smrrep;
SSettingC* repos = NULL;
TInt nosettings = 0;
HasRepositoryInSmr(smr, smrrep);
if (smrrep)
{
repos = SettingsList6; // File+Nand
nosettings = sizeof(SettingsList6) / sizeof(SSettingC);
}
else if (!smr)
{
repos = SettingsList7; // File Only
nosettings = sizeof(SettingsList7) / sizeof(SSettingC);
}
else
{
// SMR partitions found but no HCR repository
KEXT_TEST(0);
return;
}
// Simple word setting Get
for (SSettingC* setting = repos; setting < repos + nosettings; setting++)
{
// Note: these macros are irrelevant here, it is just so the two test kernel
// extensions do something different
#ifdef HCRTEST_CLIENT_THREAD
if (setting->iName.iType == ETypeInt32)
{
TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);
TInt32 val;
r = GetInt(id, val);
KEXT_TESTKERRNONE(r);
KEXT_TEST(setting->iValue.iLit.iInt32 == val);
}
#else // !HCRTEST_CLIENT_THREAD
if (setting->iName.iType == ETypeUInt32)
{
TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);
TUint32 val;
r = GetUInt(id, val);
KEXT_TESTKERRNONE(r);
KEXT_TEST(setting->iValue.iLit.iUInt32 == val);
}
#endif // !HCRTEST_CLIENT_THREAD
}
// Large setting Get
for (SSettingC* setting = repos; setting < repos + nosettings; setting++)
{
// Note: these macros are irrelevant here, it is just so the two test kernel
// extensions do something different
#ifdef HCRTEST_CLIENT_THREAD
if (setting->iName.iType == ETypeBinData)
{
TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);
TBuf8<KMaxSettingLength> val;
TPtrC8 aval(setting->iValue.iPtr.iData, setting->iName.iLen);
r = GetData(id, val);
KEXT_TESTKERRNONE(r);
KEXT_TEST(0 == val.Compare(aval));
}
#else // !HCRTEST_CLIENT_THREAD
if (setting->iName.iType == ETypeText8)
{
TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);
TBuf8<KMaxSettingLength> val;
TPtrC8 aval(setting->iValue.iPtr.iString8, setting->iName.iLen);
r = GetString(id, val);
KEXT_TESTKERRNONE(r);
KEXT_TEST(0 == val.Compare(aval));
}
#endif // !HCRTEST_CLIENT_THREAD
}
// Some other API calls
TUint i;
for (i = 0; i < sizeof(KTestCategories) / sizeof(TCategoryUid); i++)
{
r = FindNumSettingsInCategory(KTestCategories[i]);
KEXT_TEST(r >= 0);
}
}
DECLARE_EXTENSION_WITH_PRIORITY(KExtensionMaximumPriority)
{
// Set these to 0 so we know we've been here
TestKernExtensionTestLine = 0;
TestKernExtensionTestError = 0;
KextInitTests();
return KErrNone;
}
#endif // HCRTEST_USERSIDE_INTERFACE
DECLARE_EXTENSION_LDD()
{
return new DHcrSimTestDrvFactory;
}
DHcrSimTestDrvFactory::DHcrSimTestDrvFactory()
{
iParseMask = 0;
iUnitsMask = 0;
iVersion = TVersion(1,0,KE32BuildVersionNumber);
}
DHcrSimTestDrvFactory::~DHcrSimTestDrvFactory()
{
#ifndef HCRTEST_CLIENT_THREAD
if (iDfcQ)
iDfcQ->Destroy();
#endif
}
#ifndef HCRTEST_CLIENT_THREAD
const TInt KHcrSimTestThreadPriority = 1;
_LIT(KHcrSimTestThread,"HcrSimTestThread");
#endif
TInt DHcrSimTestDrvFactory::Install()
{
TInt r;
#ifndef HCRTEST_CLIENT_THREAD
r = Kern::DynamicDfcQCreate(iDfcQ, KHcrSimTestThreadPriority, KHcrSimTestThread);
if (r != KErrNone)
return r;
#ifdef HCRTEST_USERSIDE_INTERFACE
r = SetName(&KTestHcrRealOwn);
#else
r = SetName(&KTestHcrSimOwn);
#endif // HCRTEST_USERSIDE_INTERFACE
#else
#ifdef HCRTEST_USERSIDE_INTERFACE
r = SetName(&KTestHcrRealClient);
#else
r = SetName(&KTestHcrSimClient);
#endif // HCRTEST_USERSIDE_INTERFACE
#endif // HCRTEST_CLIENT_THREAD
return r;
}
void DHcrSimTestDrvFactory::GetCaps(TDes8& /*aDes*/) const
{
// Get capabilities - overriding pure virtual
}
TInt DHcrSimTestDrvFactory::Create(DLogicalChannelBase*& aChannel)
{
aChannel=new DHcrSimTestDrvChannel;
return aChannel?KErrNone:KErrNoMemory;
}
// ----------------------------------------------------------------------------
DHcrSimTestDrvChannel::DHcrSimTestDrvChannel()
{
#ifndef HCRTEST_CLIENT_THREAD
iClient=&Kern::CurrentThread();
iClient->Open();
#endif
}
DHcrSimTestDrvChannel::~DHcrSimTestDrvChannel()
{
#ifndef HCRTEST_CLIENT_THREAD
Kern::SafeClose((DObject*&)iClient, NULL);
#endif
}
TInt DHcrSimTestDrvChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)
{
#ifndef HCRTEST_CLIENT_THREAD
SetDfcQ(((DHcrSimTestDrvFactory*)iDevice)->iDfcQ);
iMsgQ.Receive();
#endif
return KErrNone;
}
#ifndef HCRTEST_CLIENT_THREAD
void DHcrSimTestDrvChannel::HandleMsg(TMessageBase* aMsg)
{
TInt r=KErrNone;
TThreadMessage& m=*(TThreadMessage*)aMsg;
TInt id=m.iValue;
if (id==(TInt)ECloseMsg)
{
m.Complete(KErrNone,EFalse);
return;
}
else
{
r=DoControl(id,m.Ptr0(),m.Ptr1());
}
m.Complete(r,ETrue);
}
#endif // HCRTEST_CLIENT_THREAD
#ifdef HCRTEST_CLIENT_THREAD
TInt DHcrSimTestDrvChannel::Request(TInt aReqNo, TAny* a1, TAny* a2)
#else
TInt DHcrSimTestDrvChannel::DoControl(TInt aReqNo, TAny* a1, TAny* a2)
#endif
{
TInt r=KErrNotSupported;
switch (aReqNo)
{
case RHcrSimTestChannel::EHcrGetLinAddr:
{
TSettingId setting;
TLinAddr value;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
r = GetLinAddr(setting, value);
TEST_MEMPUT(a2, &value, sizeof(value));
break;
}
case RHcrSimTestChannel::EHcrFindNumSettingsInCategory:
{
r = FindNumSettingsInCategory((TCategoryUid) a1);
break;
}
case RHcrSimTestChannel::EHcrFindSettingsCategory:
{
// Get list of pointers
TAny* args[6];
TEST_MEMGET(a1, args, sizeof(args));
TInt aMaxNum = (TInt) args[1];
TElementId* ids = NULL;
TSettingType* types = NULL;
TUint16* lens = NULL;
if(args[3])
{
TEST_ENTERCS();
ids = (TElementId*) Kern::Alloc(_ABS(aMaxNum) * sizeof(TElementId));
TEST_LEAVECS();
}
if (args[4]) // aTypes
{
TEST_ENTERCS();
types = (TSettingType*) Kern::Alloc(_ABS(aMaxNum) * sizeof(TSettingType));
TEST_LEAVECS();
}
if (types == NULL && args[4])
{
r = KErrNoMemory;
}
else
{
if (args[5]) // aLens
{
TEST_ENTERCS();
lens = (TUint16*) Kern::Alloc(_ABS(aMaxNum) * sizeof(TUint16));
TEST_LEAVECS();
}
if (lens == NULL && args[5])
{
r = KErrNoMemory;
}
else
{
// Actual API call
r = FindSettings((TCategoryUid) args[0],
aMaxNum, ids, types, lens);
// Send values back to client
if (r >= 0)
{
if(args[3])
{
TEST_MEMPUT(args[3], ids, _ABS(aMaxNum) * sizeof(TElementId));
if (args[4])
{
TEST_MEMPUT(args[4], types, _ABS(aMaxNum) * sizeof(TSettingType));
}
if (args[5])
{
TEST_MEMPUT(args[5], lens, _ABS(aMaxNum) * sizeof(TUint16));
}
}
}
if (args[5])
{
TEST_ENTERCS();
Kern::Free(lens);
TEST_LEAVECS();
}
}
if (args[4])
{
TEST_ENTERCS();
Kern::Free(types);
TEST_LEAVECS();
}
}
if(args[3])
{
TEST_ENTERCS();
Kern::Free(ids);
TEST_LEAVECS();
}
break;
}
case RHcrSimTestChannel::EHcrFindSettingsPattern:
{
// Get list of pointers
TAny* args[8];
TEST_MEMGET(a1, args, sizeof(args));
TInt aMaxNum = (TInt) args[1];
// Allocate temporary memory
TElementId* ids = NULL;
TSettingType* types = NULL;
TUint16* lens = NULL;
if(args[5])
{
TEST_ENTERCS();
ids = (TElementId*) Kern::Alloc(_ABS(aMaxNum) * sizeof(TElementId));
if(!ids)
return KErrNoMemory;
TEST_LEAVECS();
}
if (args[6]) // aTypes
{
TEST_ENTERCS();
types = (TSettingType*) Kern::Alloc(_ABS(aMaxNum) * sizeof(TSettingType));
TEST_LEAVECS();
}
if (types == NULL && args[6])
{
r = KErrNoMemory;
}
else
{
if (args[7]) // aLens
{
TEST_ENTERCS();
lens = (TUint16*) Kern::Alloc(_ABS(aMaxNum) * sizeof(TUint16));
TEST_LEAVECS();
}
if (lens == NULL && args[7])
{
r = KErrNoMemory;
}
else
{
// Actual API call
r = FindSettings((TCategoryUid) args[0],
aMaxNum, (TUint32) args[2], (TUint32) args[3],
ids, types, lens);
// Send values back to client
if (r > 0)
{
TEST_MEMPUT(args[5], ids, _ABS(aMaxNum) * sizeof(TElementId));
if (args[6])
{
TEST_MEMPUT(args[6], types, _ABS(aMaxNum) * sizeof(TSettingType));
}
if (args[7])
{
TEST_MEMPUT(args[7], lens, _ABS(aMaxNum) * sizeof(TUint16));
}
}
if (args[7])
{
TEST_ENTERCS();
Kern::Free(lens);
TEST_LEAVECS();
}
}
if (args[6])
{
TEST_ENTERCS();
Kern::Free(types);
TEST_LEAVECS();
}
}
if(args[5])
{
TEST_ENTERCS();
Kern::Free(ids);
TEST_LEAVECS();
}
break;
}
case RHcrSimTestChannel::EHcrGetTypeAndSize:
{
// Get list of pointers
TAny* args[3];
TEST_MEMGET(a1, args, sizeof(args));
TSettingId id;
TEST_MEMGET(args[0], &id, sizeof(TSettingId));
TSettingType type;
TUint16 len;
r = GetTypeAndSize(id, type, len);
TEST_MEMPUT(args[1], &type, sizeof(TSettingType));
TEST_MEMPUT(args[2], &len, sizeof(TUint16));
break;
}
case RHcrSimTestChannel::EHcrGetWordSettings:
{
// Get list of pointers
TAny* args[5];
TEST_MEMGET(a1, args, sizeof(args));
TInt aNum = (TInt) args[0];
// Allocate temporary memory
SSettingId* ids;
SSettingId* inIds = (SSettingId*)args[1];
TInt32* vals;
TSettingType* types= NULL;
TInt* errors = NULL;
TEST_ENTERCS();
if(inIds)
{
ids = (SSettingId*) Kern::Alloc((aNum>=0?aNum:-aNum) * sizeof(SSettingId));
//Read data from the user side
if (ids == NULL)
{
r = KErrNoMemory;
break;
}
TEST_MEMGET(inIds, ids, (aNum>=0?aNum:-aNum) * sizeof(SSettingId));
}
else
ids = NULL;
TEST_LEAVECS();
if (args[2]) //values
{
TEST_ENTERCS();
vals = (TInt32*) Kern::Alloc((aNum>=0?aNum:-aNum) * sizeof(TInt32));
TEST_LEAVECS();
if (vals == NULL)
{
r = KErrNoMemory;
break;
}
}
else
vals = NULL;
if (args[3]) // aTypes
{
TEST_ENTERCS();
types = (TSettingType*) Kern::Alloc((aNum>=0?aNum:-aNum) *
sizeof(TSettingType));
TEST_LEAVECS();
}
if (types == NULL && args[3])
{
r = KErrNoMemory;
}
else
{
if (args[4]) // aErrors
{
TEST_ENTERCS();
errors = (TInt*) Kern::Alloc((aNum>=0?aNum:-aNum) * sizeof(TInt));
TEST_LEAVECS();
}
if (errors == NULL && args[4])
{
r = KErrNoMemory;
}
else
{
// Actual API call
r = GetWordSettings(aNum, ids, vals, types, errors);
// Send values back to client
if (r >= 0)
{
TEST_MEMPUT(args[1], ids, aNum * sizeof(SSettingId));
TEST_MEMPUT(args[2], vals, aNum * sizeof(TInt32));
if (args[3])
{
TEST_MEMPUT(args[3], types,(aNum>=0?aNum:-aNum) * sizeof(TSettingType));
}
if (args[4])
{
TEST_MEMPUT(args[4], errors, (aNum>=0?aNum:-aNum) * sizeof(TInt));
}
}
if (args[4])
{
TEST_ENTERCS();
Kern::Free(errors);
TEST_LEAVECS();
}
}
if (args[3])
{
TEST_ENTERCS();
Kern::Free(types);
TEST_LEAVECS();
}
}
if (args[2])
{
TEST_ENTERCS();
Kern::Free(vals);
TEST_LEAVECS();
}
TEST_ENTERCS();
if(inIds)
Kern::Free(ids);
TEST_LEAVECS();
break;
}
case RHcrSimTestChannel::EHcrGetInt64:
{
TSettingId setting;
TInt64 value;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
r = GetInt(setting, value);
TEST_MEMPUT(a2, &value, sizeof(value));
break;
}
case RHcrSimTestChannel::EHcrGetInt32:
{
TSettingId setting;
TInt32 value;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
r = GetInt(setting, value);
TEST_MEMPUT(a2, &value, sizeof(value));
break;
}
case RHcrSimTestChannel::EHcrGetInt16:
{
TSettingId setting;
TInt16 value;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
r = GetInt(setting, value);
TEST_MEMPUT(a2, &value, sizeof(value));
break;
}
case RHcrSimTestChannel::EHcrGetInt8:
{
TSettingId setting;
TInt8 value;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
r = GetInt(setting, value);
TEST_MEMPUT(a2, &value, sizeof(value));
break;
}
case RHcrSimTestChannel::EHcrGetBool:
{
TSettingId setting;
TBool value;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
r = GetBool(setting, value);
TEST_MEMPUT(a2, &value, sizeof(value));
break;
}
case RHcrSimTestChannel::EHcrGetDataArray:
{
// Get list of pointers
TAny* args[4];
TEST_MEMGET(a1, args, sizeof(args));
TUint maxlen = (TUint) args[1];
// Retrieve structures from client
TSettingId id;
TEST_MEMGET(args[0], &id, sizeof(TSettingId));
// Allocate temporary memory
TUint16 len;
TUint8* value;
TEST_ENTERCS();
value = (TUint8*) Kern::Alloc(maxlen * sizeof(TUint8));
TEST_LEAVECS();
if (value == NULL)
{
r = KErrNoMemory;
}
else
{
// Actual API call
r = GetData(id, (TUint16) maxlen,
value, len);
// Send value back to client
if (!r)
{
TEST_MEMPUT(args[2], value, maxlen * sizeof(TUint8));
TEST_MEMPUT(args[3], &len, sizeof(TUint16));
}
TEST_ENTERCS();
Kern::Free(value);
TEST_LEAVECS();
}
break;
}
case RHcrSimTestChannel::EHcrGetDataDes:
{
TSettingId setting;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
TInt userdes[sizeof(TDes8) / sizeof(TInt) + 1];
TEST_MEMGET(a2, userdes, sizeof(TDes8));
HBuf8* value;
TEST_ENTERCS();
value = HBuf8::New(userdes[1]);
TEST_LEAVECS();
if (value == NULL)
{
r = KErrNoMemory;
}
else
{
r = GetData(setting, *value);
TEST_DESPUT(a2, *value);
TEST_ENTERCS();
delete value;
TEST_LEAVECS();
}
break;
}
case RHcrSimTestChannel::EHcrGetUInt64:
{
TSettingId setting;
TUint64 value;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
r = GetUInt(setting, value);
TEST_MEMPUT(a2, &value, sizeof(value));
break;
}
case RHcrSimTestChannel::EHcrGetUInt32:
{
TSettingId setting;
TUint32 value;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
r = GetUInt(setting, value);
TEST_MEMPUT(a2, &value, sizeof(value));
break;
}
case RHcrSimTestChannel::EHcrGetUInt16:
{
TSettingId setting;
TUint16 value;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
r = GetUInt(setting, value);
TEST_MEMPUT(a2, &value, sizeof(value));
break;
}
case RHcrSimTestChannel::EHcrGetUInt8:
{
TSettingId setting;
TUint8 value;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
r = GetUInt(setting, value);
TEST_MEMPUT(a2, &value, sizeof(value));
break;
}
case RHcrSimTestChannel::EHcrGetArrayInt:
{
// Get list of pointers
TAny* args[4];
TEST_MEMGET(a1, args, sizeof(args));
TUint maxlen = (TUint) args[1];
// Retrieve structures from client
TSettingId id;
TEST_MEMGET(args[0], &id, sizeof(TSettingId));
// Allocate temporary memory
TUint16 len;
TInt32* value;
TEST_ENTERCS();
value = (TInt32*) Kern::Alloc(maxlen);
TEST_LEAVECS();
if (value == NULL)
{
r = KErrNoMemory;
}
else
{
// Actual API call
r = GetArray(id, (TUint16) maxlen,
value, len);
// Send value back to client
if (!r)
{
TEST_MEMPUT(args[2], value, maxlen);
TEST_MEMPUT(args[3], &len, sizeof(TUint16));
}
TEST_ENTERCS();
Kern::Free(value);
TEST_LEAVECS();
}
break;
}
case RHcrSimTestChannel::EHcrGetArrayUInt:
{
// Get list of pointers
TAny* args[4];
TEST_MEMGET(a1, args, sizeof(args));
TUint maxlen = (TUint) args[1];
// Retrieve structures from client
TSettingId id;
TEST_MEMGET(args[0], &id, sizeof(TSettingId));
// Allocate temporary memory
TUint16 len;
TUint32* value;
TEST_ENTERCS();
value = (TUint32*) Kern::Alloc(maxlen);
TEST_LEAVECS();
if (value == NULL)
{
r = KErrNoMemory;
}
else
{
// Actual API call
r = GetArray(id, (TUint16) maxlen,
value, len);
// Send value back to client
if (!r)
{
TEST_MEMPUT(args[2], value, maxlen);
TEST_MEMPUT(args[3], &len, sizeof(TUint16));
}
TEST_ENTERCS();
Kern::Free(value);
TEST_LEAVECS();
}
break;
}
case RHcrSimTestChannel::EHcrGetStringArray:
{
// Get list of pointers
TAny* args[4];
TEST_MEMGET(a1, args, sizeof(args));
TUint maxlen = (TUint) args[1];
// Retrieve structures from client
TSettingId id;
TEST_MEMGET(args[0], &id, sizeof(TSettingId));
// Allocate temporary memory
TUint16 len;
TText8* value;
TEST_ENTERCS();
value = (TText8*) Kern::Alloc(maxlen * sizeof(TText8));
TEST_LEAVECS();
if (value == NULL)
{
r = KErrNoMemory;
}
else
{
// Actual API call
r = GetString(id, (TUint16) maxlen,
value, len);
// Send value back to client
if (!r)
{
TEST_MEMPUT(args[2], value, maxlen * sizeof(TText8));
TEST_MEMPUT(args[3], &len, sizeof(TUint16));
}
TEST_ENTERCS();
Kern::Free(value);
TEST_LEAVECS();
}
break;
}
case RHcrSimTestChannel::EHcrGetStringDes:
{
TSettingId setting;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
TInt userdes[sizeof(TDes8) / sizeof(TInt) + 1];
TEST_MEMGET(a2, userdes, sizeof(TDes8));
HBuf8* value;
TEST_ENTERCS();
value = HBuf8::New(userdes[1]);
TEST_LEAVECS();
if (value == NULL)
{
r = KErrNoMemory;
}
else
{
r = GetString(setting, *value);
TEST_DESPUT(a2, *value);
TEST_ENTERCS();
delete value;
TEST_LEAVECS();
}
break;
}
#ifndef HCRTEST_USERSIDE_INTERFACE
case RHcrSimTestChannel::EHcrInitExtension:
{
PslConfigurationFlags = (TInt) a1;
TEST_ENTERCS();
r = InitExtension();
TEST_LEAVECS();
break;
}
case RHcrSimTestChannel::EHcrSwitchRepository:
{
TBuf8<80> filename;
TEST_DESGET(a1, filename);
TText8 filestr[81];
memcpy(filestr, filename.Ptr(), filename.Length());
filestr[filename.Length()] = 0; // Zero-terminate string
TText8* pfile = filestr;
if (filename.Length() == 0)
{
pfile = NULL;
}
if ((TUint) a2 == HCRInternal::ECoreRepos)
{
r = HCRSingleton->SwitchRepository(pfile, HCRInternal::ECoreRepos);
}
else if ((TUint) a2 == HCRInternal::EOverrideRepos)
{
r = HCRSingleton->SwitchRepository(pfile, HCRInternal::EOverrideRepos);
}
break;
}
case RHcrSimTestChannel::EHcrCheckIntegrity:
{
r = HCRSingleton->CheckIntegrity();
break;
}
#endif // HCRTEST_USERSIDE_INTERFACE
case RHcrSimTestChannel::EHcrGetInitExtensionTestResults:
{
r = KErrNone;
TEST_MEMPUT(a1, (TAny*) &TestKernExtensionTestLine, sizeof(TInt));
TEST_MEMPUT(a2, (TAny*) &TestKernExtensionTestError, sizeof(TInt));
}
break;
case RHcrSimTestChannel::EHcrHasRepositoryInSmr:
{
r = KErrNone;
TBool smr;
TBool smrrep;
HasRepositoryInSmr(smr, smrrep);
TEST_MEMPUT(a1, (TAny*) &smr, sizeof(TBool));
TEST_MEMPUT(a2, (TAny*) &smrrep, sizeof(TBool));
}
break;
case RHcrSimTestChannel::EHcrBenchmarkGetSettingInt:
{
r = KErrNone;
TUint i;
TSettingId setting;
TInt32 value;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
//
TUint32 start = NKern::TickCount();
for (i = 0; i < KTestBenchmarkIterations; i++)
{
r |= GetInt(setting, value);
}
TUint32 end = NKern::TickCount();
//
TUint32 ms;
ms = ((end - start) * NKern::TickPeriod()) / 1000;
TEST_MEMPUT(a2, (TAny*) &ms, sizeof(TUint32));
}
break;
case RHcrSimTestChannel::EHcrBenchmarkGetSettingArray:
{
r = KErrNone;
TUint i;
TSettingId setting;
TText8* value;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
// Allocate temporary memory
TEST_ENTERCS();
value = (TText8*) Kern::Alloc(KMaxSettingLength);
TEST_LEAVECS();
if (value == NULL)
{
r = KErrNoMemory;
}
else
{
TUint16 len;
TUint32 start = NKern::TickCount();
for (i = 0; i < KTestBenchmarkIterations; i++)
{
r |= GetString(setting, (TUint16) KMaxSettingLength, value, len);
}
TUint32 end = NKern::TickCount();
//
TUint32 ms;
ms = ((end - start) * NKern::TickPeriod()) / 1000;
TEST_MEMPUT(a2, (TAny*) &ms, sizeof(TUint32));
TEST_ENTERCS();
Kern::Free(value);
TEST_LEAVECS();
}
}
break;
case RHcrSimTestChannel::EHcrBenchmarkGetSettingDes:
{
r = KErrNone;
TUint i;
TSettingId setting;
TBuf8<KMaxSettingLength> value;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
TUint32 start = NKern::TickCount();
for (i = 0; i < KTestBenchmarkIterations; i++)
{
r |= GetString(setting, value);
}
TUint32 end = NKern::TickCount();
//
TUint32 ms;
ms = ((end - start) * NKern::TickPeriod()) / 1000;
TEST_MEMPUT(a2, (TAny*) &ms, sizeof(TUint32));
}
break;
case RHcrSimTestChannel::EHcrBenchmarkFindNumSettingsInCategory:
{
r = 0;
TUint i;
TUint32 start = NKern::TickCount();
for (i = 0; i < KTestBenchmarkIterations; i++)
{
r |= FindNumSettingsInCategory((TCategoryUid) a1);
}
TUint32 end = NKern::TickCount();
//
TUint32 ms;
ms = ((end - start) * NKern::TickPeriod()) / 1000;
TEST_MEMPUT(a2, (TAny*) &ms, sizeof(TUint32));
}
break;
case RHcrSimTestChannel::EHcrBenchmarkFindSettings:
{
r = 0;
TUint i;
TElementId* ids;
TSettingType* types;
TUint16* lens;
TEST_ENTERCS();
ids = (TElementId*) Kern::Alloc(KTestBenchmarkNumberOfSettingsInCategory * sizeof(TElementId));
TEST_LEAVECS();
if (!ids)
{
TEST(EFalse);
r = KErrNoMemory;
}
else
{
TEST_ENTERCS();
types = (TSettingType*) Kern::Alloc(KTestBenchmarkNumberOfSettingsInCategory * sizeof(TSettingType));
TEST_LEAVECS();
if (!types)
{
TEST(EFalse);
r = KErrNoMemory;
}
else
{
TEST_ENTERCS();
lens = (TUint16*) Kern::Alloc(KTestBenchmarkNumberOfSettingsInCategory * sizeof(TUint16));
TEST_LEAVECS();
if (!lens)
{
TEST(EFalse);
r = KErrNoMemory;
}
else
{
TUint32 start = NKern::TickCount();
for (i = 0; i < KTestBenchmarkIterations; i++)
{
r |= FindSettings((TCategoryUid) a1,
KTestBenchmarkNumberOfSettingsInCategory,
ids, types, lens);
}
TUint32 end = NKern::TickCount();
//
TUint32 ms;
ms = ((end - start) * NKern::TickPeriod()) / 1000;
TEST_MEMPUT(a2, (TAny*) &ms, sizeof(TUint32));
TEST_ENTERCS();
Kern::Free(lens);
TEST_LEAVECS();
}
TEST_ENTERCS();
Kern::Free(types);
TEST_LEAVECS();
}
TEST_ENTERCS();
Kern::Free(ids);
TEST_LEAVECS();
}
}
break;
case RHcrSimTestChannel::EHcrBenchmarkGetTypeAndSize:
{
r = KErrNone;
TUint i;
TSettingId setting;
TSettingType type;
TUint16 len;
TEST_MEMGET(a1, &setting, sizeof(TSettingId));
//
TUint32 start = NKern::TickCount();
for (i = 0; i < KTestBenchmarkIterations; i++)
{
r |= GetTypeAndSize(setting, type, len);
}
TUint32 end = NKern::TickCount();
//
TUint32 ms;
ms = ((end - start) * NKern::TickPeriod()) / 1000;
TEST_MEMPUT(a2, (TAny*) &ms, sizeof(TUint32));
}
break;
case RHcrSimTestChannel::EHcrBenchmarkGetWordSettings:
{
r = 0;
TUint i;
SSettingId* ids;
TSettingType* types;
TCategoryUid catId = (TCategoryUid)a1;
TInt32* values;
TInt* errors;
TEST_ENTERCS();
//We allocate here KTestBenchmarkNumberOfSettingsInCategory - 1 because
//last element in the category is a large setting
ids = (SSettingId*) Kern::Alloc((KTestBenchmarkNumberOfSettingsInCategory - 1) * sizeof(SSettingId));
TEST_LEAVECS();
if (!ids)
{
TEST(EFalse);
r = KErrNoMemory;
}
else
{
for(TUint eId =0; eId < KTestBenchmarkNumberOfSettingsInCategory - 1; eId++ )
{
ids[eId].iCat = catId;
//First element has value 1, second 2, third 3 and so on
ids[eId].iKey = eId + 1;
}
TEST_ENTERCS();
types = (TSettingType*) Kern::Alloc((KTestBenchmarkNumberOfSettingsInCategory - 1) * sizeof(TSettingType));
TEST_LEAVECS();
if (!types)
{
TEST(EFalse);
r = KErrNoMemory;
}
else
{
TEST_ENTERCS();
values = (TInt32*) Kern::Alloc((KTestBenchmarkNumberOfSettingsInCategory - 1) * sizeof(TInt32));
TEST_LEAVECS();
if (!values)
{
TEST(EFalse);
r = KErrNoMemory;
}
else
{
TEST_ENTERCS();
errors = (TInt*) Kern::Alloc((KTestBenchmarkNumberOfSettingsInCategory - 1) * sizeof(TInt));
TEST_LEAVECS();
if (!errors)
{
TEST(EFalse);
r = KErrNoMemory;
}
else
{
TUint32 start = NKern::TickCount();
for (i = 0; i < KTestGetMultipleBenchmarkIterations; i++)
{
r |= GetWordSettings(KTestBenchmarkNumberOfSettingsInCategory - 1, ids, values, types, errors);
}
TUint32 end = NKern::TickCount();
//
TUint32 ms;
ms = ((end - start) * NKern::TickPeriod()) / 1000;
TEST_MEMPUT(a2, (TAny*) &ms, sizeof(TUint32));
TEST_ENTERCS();
Kern::Free(errors);
TEST_LEAVECS();
}
TEST_ENTERCS();
Kern::Free(values);
TEST_LEAVECS();
}
TEST_ENTERCS();
Kern::Free(types);
TEST_LEAVECS();
}
TEST_ENTERCS();
Kern::Free(ids);
TEST_LEAVECS();
}
}
break;
}
return r;
}