diff -r a179b74831c9 -r c1f20ce4abcf kerneltest/e32test/hcr/t_hcr.cpp --- a/kerneltest/e32test/hcr/t_hcr.cpp Thu Aug 19 11:14:22 2010 +0300 +++ b/kerneltest/e32test/hcr/t_hcr.cpp Tue Aug 31 16:34:26 2010 +0300 @@ -147,22 +147,27 @@ { TBuf8 dval; TUint8* pval; - pval = (TUint8*) User::Alloc(setting->iName.iLen); + 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, setting->iName.iLen, pval, actuallength); + r = HcrSimTest.GetData(id, maxLen, 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())); + 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; } @@ -170,35 +175,41 @@ { TBuf8 dval; TText8* pval; - pval = (TText8*) User::Alloc(setting->iName.iLen); + 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, setting->iName.iLen, pval, actuallength); + r = HcrSimTest.GetString(id, maxLen, 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())); + + 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; - pval = (TInt32*) User::Alloc(setting->iName.iLen); + 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, setting->iName.iLen, pval, 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; @@ -212,12 +223,14 @@ case ETypeArrayUInt32: { TUint32* pval; - pval = (TUint32*) User::Alloc(setting->iName.iLen); + 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, setting->iName.iLen, pval, actuallength); + r = HcrSimTest.GetArray(id, maxLen, pval, actuallength); test_KErrNone(r); + // test_Equal(setting->iName.iLen, actuallength); TUint32* pexpected = setting->iValue.iPtr.iArrayUInt32; @@ -426,7 +439,135 @@ 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) @@ -815,6 +956,68 @@ 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) { @@ -2430,6 +2633,500 @@ 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")); @@ -2639,7 +3336,9 @@ HcrPslTests(KTestHcrSimClient); HcrSimTests(KTestHcrSimOwn); HcrSimTests(KTestHcrSimClient); - + + HcrCatRecodsExampleTest(KTestHcrSimOwn); + HcrCatRecodsExampleTest(KTestHcrSimClient); //Benchmark tests HcrSimBenchmarkTests(KTestHcrSimOwn);