diff -r 4122176ea935 -r 56f325a607ea kerneltest/e32test/hcr/t_hcr.cpp --- a/kerneltest/e32test/hcr/t_hcr.cpp Mon Dec 21 16:14:42 2009 +0000 +++ b/kerneltest/e32test/hcr/t_hcr.cpp Wed Dec 23 11:43:31 2009 +0000 @@ -16,12 +16,51 @@ #define __E32TEST_EXTENSION__ #include +#include +#include +#include +#include #include "d_hcrsim.h" #include "d_hcrsim_testdata.h" +#include "hcr_uids.h" + +_LIT8(KTestFileRepos, "filerepos.dat"); +_LIT8(KTestNandRepos, "nandrepos.dat"); +_LIT8(KTestCorrupt1, "corrupt1.dat"); +_LIT8(KTestCorrupt2, "corrupt2.dat"); +_LIT8(KTestEmpty, "empty.dat"); +_LIT8(KTestMegaLarge1, "megalarge1.dat"); +_LIT8(KTestMegaLarge2, "megalarge2.dat"); +_LIT8(KTestClearRepos, ""); + + RTest test(_L("T_HCR")); RHcrSimTestChannel HcrSimTest; +//Helper function to compare two SSettingId parameters. It's used in +//GetMultipleWord settings array +TInt CompareEntries (const SSettingC& a1, const SSettingC& a2) + { + if (a1.iName.iId.iCat > a2.iName.iId.iCat) + return (1); + + if (a1.iName.iId.iCat < a2.iName.iId.iCat) + return (-1); + + // Categories are the same at this point, check keys. + if (a1.iName.iId.iKey > a2.iName.iId.iKey) + return (1); + + if (a1.iName.iId.iKey < a2.iName.iId.iKey) + return (-1); + + // Both Categories and jeys are the same here. + return (0); + } + + + void HcrSimGetSettings(SSettingC* aRepository, TUint aNumberOfSettings) { test.Next(_L("GetSettings")); @@ -278,6 +317,15 @@ // User::Free(pval); } + else if (setting->iName.iLen > 1) + { + RBuf8 dval; + r = dval.Create(setting->iName.iLen - 1); + test_KErrNone(r); + r = HcrSimTest.GetData(id, dval); + test_Equal(KErrTooBig, r); + dval.Close(); + } if (setting->iName.iType != ETypeText8) { TBuf8 dval; @@ -294,6 +342,15 @@ // User::Free(pval); } + else if (setting->iName.iLen > 1) + { + RBuf8 dval; + r = dval.Create(setting->iName.iLen - 1); + test_KErrNone(r); + r = HcrSimTest.GetString(id, dval); + test_Equal(KErrTooBig, r); + dval.Close(); + } if (setting->iName.iType != ETypeArrayInt32) { TInt32* pval; @@ -306,6 +363,18 @@ // User::Free(pval); } + else + { + TInt32* pval; + pval = (TInt32*) User::Alloc(setting->iName.iLen); + test_NotNull(pval); + // + TUint16 actuallength; + r = HcrSimTest.GetArray(id, (TUint16) (setting->iName.iLen / 2), pval, actuallength); + test_Equal(KErrTooBig, r); + // + User::Free(pval); + } if (setting->iName.iType != ETypeArrayUInt32) { TUint32* pval; @@ -333,224 +402,6 @@ } } -void HcrSimGetSettingsNotFound(const TUint32 aInvalidCategory, const TUint32 aInvalidSettingId) - { - test.Next(_L("GetSettingsNotFound")); - TSettingId id(aInvalidCategory, aInvalidSettingId); - TInt r; - { - TInt32 val; - r = HcrSimTest.GetInt(id, val); - test_Equal(KErrNotFound, r); - } - { - TInt16 val; - r = HcrSimTest.GetInt(id, val); - test_Equal(KErrNotFound, r); - } - { - TInt8 val; - r = HcrSimTest.GetInt(id, val); - test_Equal(KErrNotFound, r); - } - { - TBool val; - r = HcrSimTest.GetBool(id, val); - test_Equal(KErrNotFound, r); - } - { - TUint32 val; - r = HcrSimTest.GetUInt(id, val); - test_Equal(KErrNotFound, r); - } - { - TUint16 val; - r = HcrSimTest.GetUInt(id, val); - test_Equal(KErrNotFound, r); - } - { - TUint8 val; - r = HcrSimTest.GetUInt(id, val); - test_Equal(KErrNotFound, r); - } - { - TLinAddr val; - r = HcrSimTest.GetLinAddr(id, val); - test_Equal(KErrNotFound, r); - } - { - TBuf8 dval; - TUint8* pval; - pval = (TUint8*) User::Alloc(KMaxSettingLength); - test_NotNull(pval); - // - r = HcrSimTest.GetData(id, dval); - test_Equal(KErrNotFound, r); - // - TUint16 actuallength; - r = HcrSimTest.GetData(id, KMaxSettingLength, pval, actuallength); - test_Equal(KErrNotFound, r); - // - User::Free(pval); - } - { - TBuf8 dval; - TText8* pval; - pval = (TText8*) User::Alloc(KMaxSettingLength); - test_NotNull(pval); - // - r = HcrSimTest.GetString(id, dval); - test_Equal(KErrNotFound, r); - // - TUint16 actuallength; - r = HcrSimTest.GetString(id, KMaxSettingLength, pval, actuallength); - test_Equal(KErrNotFound, 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(KErrNotFound, 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(KErrNotFound, r); - // - User::Free(pval); - } - { - TInt64 val; - r = HcrSimTest.GetInt(id, val); - test_Equal(KErrNotFound, r); - } - { - TUint64 val; - r = HcrSimTest.GetUInt(id, val); - test_Equal(KErrNotFound, r); - } - } - -void HcrSimGetSettingsNotReady() - { - test.Next(_L("GetSettingsNotReady")); - TSettingId id(1, 1); - TInt r; - { - TInt32 val; - r = HcrSimTest.GetInt(id, val); - test_Equal(KErrNotReady, r); - } - { - TInt16 val; - r = HcrSimTest.GetInt(id, val); - test_Equal(KErrNotReady, r); - } - { - TInt8 val; - r = HcrSimTest.GetInt(id, val); - test_Equal(KErrNotReady, r); - } - { - TBool val; - r = HcrSimTest.GetBool(id, val); - test_Equal(KErrNotReady, r); - } - { - TUint32 val; - r = HcrSimTest.GetUInt(id, val); - test_Equal(KErrNotReady, r); - } - { - TUint16 val; - r = HcrSimTest.GetUInt(id, val); - test_Equal(KErrNotReady, r); - } - { - TUint8 val; - r = HcrSimTest.GetUInt(id, val); - test_Equal(KErrNotReady, r); - } - { - TLinAddr val; - r = HcrSimTest.GetLinAddr(id, val); - test_Equal(KErrNotReady, r); - } - { - TBuf8 dval; - TUint8* pval; - pval = (TUint8*) User::Alloc(KMaxSettingLength); - test_NotNull(pval); - // - r = HcrSimTest.GetData(id, dval); - test_Equal(KErrNotReady, r); - // - TUint16 actuallength; - r = HcrSimTest.GetData(id, KMaxSettingLength, pval, actuallength); - test_Equal(KErrNotReady, r); - // - User::Free(pval); - } - { - TBuf8 dval; - TText8* pval; - pval = (TText8*) User::Alloc(KMaxSettingLength); - test_NotNull(pval); - // - r = HcrSimTest.GetString(id, dval); - test_Equal(KErrNotReady, r); - // - TUint16 actuallength; - r = HcrSimTest.GetString(id, KMaxSettingLength, pval, actuallength); - test_Equal(KErrNotReady, 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(KErrNotReady, 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(KErrNotReady, r); - // - User::Free(pval); - } - { - TInt64 val; - r = HcrSimTest.GetInt(id, val); - test_Equal(KErrNotReady, r); - } - { - TUint64 val; - r = HcrSimTest.GetUInt(id, val); - test_Equal(KErrNotReady, r); - } - } - void HcrSimSettingProperties(SSettingC* aRepository, TUint aNumberOfSettings) { test.Next(_L("SettingProperties")); @@ -599,45 +450,140 @@ { 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")); - SSettingC* setting; + for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++) { if (setting->iName.iType < 0x00010000) { - SSettingId id; - id.iCat = setting->iName.iId.iCat; - id.iKey = setting->iName.iId.iKey; 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 - for (i = 0; i < (2 ^ 2); i++) + // 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++) { - test.Printf(_L("-Permutation %02x\n"), i); - TInt32 val; - TSettingType type; - TInt err; - r = HcrSimTest.GetWordSettings(1, &id, &val, - // Optional values - (i & 0x1 ? &type : NULL), - (i & 0x10 ? &err : NULL)); - test_KErrNone(r); - test_Equal(setting->iValue.iLit.iInt32, val); - if (i & 0x1) + //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_Equal(setting->iName.iType, type); + //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); } - if (i & 0x10) + + //Invalid category and valid element id + if(i == 4 || i == 5) { - test_KErrNone(err); + 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.Start(_L("Multiple Get on all settings")); - TUint nosettings = 0; + + + 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) @@ -646,10 +592,14 @@ } 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); @@ -658,7 +608,9 @@ 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) @@ -669,15 +621,78 @@ } } 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 ^ 2); i++) + for (i = 0; i < 2; i++) { r = HcrSimTest.GetWordSettings(nosettings, ids, vals, - // Optional values - (i & 0x1 ? types : NULL), - (i & 0x10 ? errs : NULL)); - test_KErrNone(r); + (i & 0x1 ? types : NULL), errs); + //HCR returns number of found elements + test_Equal(nosettings, r); // Check values n = 0; @@ -688,12 +703,81 @@ 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]); } - if (i & 0x10) - { - test_KErrNone(errs[n]); - } + + test_KErrNone(errs[n]); + n++; } } @@ -703,21 +787,562 @@ 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 HcrSimTests() +void HcrSimNumSettingsInCategory(SSettingC* aRepository, TUint aNumberOfSettings) + { + test.Next(_L("NumSettingsInCategory")); + TInt r; + // Build a hash table with number of settings for each category + RHashMap 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::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 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::TIter catiter(numsettings); + for (;;) + { + const TUint32* nextcat = catiter.NextKey(); + if (!nextcat) + { + break; + } + test.Printf(_L("Category %08x"), *nextcat); + const TInt* v = numsettings.Find(*nextcat); + test_NotNull(v); + + // Allocate memory for holding array of settings + TElementId* elids; + TSettingType* types; + TUint16* lens; + elids = (TElementId*) User::Alloc(*v * sizeof(TElementId)); + test_NotNull(elids); + types = (TSettingType*) User::Alloc(*v * sizeof(TSettingType)); + test_NotNull(types); + lens = (TUint16*) User::Alloc(*v * sizeof(TUint16)); + test_NotNull(lens); + + // Try all permutations of optional values + TInt i; + for (i = 0; i < 3; i++) + { + test.Printf(_L(".")); + Mem::Fill(elids, *v * sizeof(TElementId), 0xcc); + Mem::Fill(types, *v * sizeof(TSettingType), 0xcc); + Mem::Fill(lens, *v * sizeof(TUint16), 0xcc); + TUint32 numfound; + r = HcrSimTest.FindSettings(*nextcat, + *v, numfound, + elids, + i & 0x1 ? types : NULL, + i & 0x2 ? lens : NULL); + numfound = r; + test_Compare(0, <=, r); + test_Equal(*v, r); + + + // Check returned list of element ids + TUint j; + for (j = 0; j < numfound; j++) + { + // Find current element in the test array + for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++) + { + if ((setting->iName.iId.iCat == *nextcat) && (setting->iName.iId.iKey == elids[j])) + { + break; + } + } + test_Compare(setting,<,aRepository+aNumberOfSettings); // Fail if element not found + switch (setting->iName.iType) + { + case ETypeInt32: + case ETypeInt16: + case ETypeInt8: + case ETypeBool: + case ETypeUInt32: + case ETypeUInt16: + case ETypeUInt8: + case ETypeLinAddr: + if (i & 0x1) + { + test_Equal(setting->iName.iType, types[j]); + } + if (i & 0x2) + { + test_Equal(0, lens[j]); + } + break; + // Fall-through + case ETypeBinData: + case ETypeText8: + case ETypeArrayInt32: + case ETypeArrayUInt32: + case ETypeInt64: + case ETypeUInt64: + if (i & 0x1) + { + test_Equal(setting->iName.iType, types[j]); + } + if (i & 0x2) + { + test_Equal(setting->iName.iLen, lens[j]); + } + break; + default: + test(EFalse); + } + } + // Check all expected elements are in the returned list of element ids + for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++) + { + if ((setting->iName.iId.iCat == *nextcat)) + { + for (j = 0; j < numfound; j++) + { + if (elids[j] == setting->iName.iId.iKey) + { + break; + } + } + test_Compare(j, <=, numfound); + } + } + } + User::Free(elids); + User::Free(types); + User::Free(lens); + test.Printf(_L("\n")); + } + numsettings.Close(); + } + +struct TTestFindSettingsPatternArgs + { + TUint32 iMask; + TUint32 iPattern; + }; + +const TTestFindSettingsPatternArgs KTestFindSettingsPatternArgs[] = { +// iMask iPattern + {0x00000000, 0x00000000}, +/* {0xfffffff0, 0x00000000}, + {0xffffffff, 0x00000001},*/ +}; + +void HcrSimFindSettingsPattern(SSettingC* aRepository, TUint aNumberOfSettings) { - test.Next(_L("HCR Simulator tests")); + test.Next(_L("FindSettingsPattern")); + TInt r; + TUint i; + + // Allocate memory for holding array of settings + TElementId* elids; + TSettingType* types; + TUint16* lens; + elids = (TElementId*) User::Alloc(aNumberOfSettings * sizeof(TElementId)); + test_NotNull(elids); + types = (TSettingType*) User::Alloc(aNumberOfSettings * sizeof(TSettingType)); + test_NotNull(types); + lens = (TUint16*) User::Alloc(aNumberOfSettings * sizeof(TUint16)); + test_NotNull(lens); + + for (i = 0; i < sizeof(KTestFindSettingsPatternArgs) / sizeof(TTestFindSettingsPatternArgs); i++) + { + test.Printf(_L("iMask=0x%08x iPattern=0x%08x\n"), + KTestFindSettingsPatternArgs[i].iMask, + KTestFindSettingsPatternArgs[i].iPattern); + + // Test each category + TUint j; + for (j = 0; j < sizeof(KTestCategories) / sizeof(TCategoryUid); j++) + { + test.Printf(_L("Category 0x%08x: "), KTestCategories[j]); + + // Test all possible permutations of optional arguments + TUint k; + for (k = 0; k < 3; k++) + { + TUint32 numfound; + // Actual API call + r = HcrSimTest.FindSettings( + KTestCategories[j], + aNumberOfSettings, + KTestFindSettingsPatternArgs[i].iMask, + KTestFindSettingsPatternArgs[i].iPattern, + numfound, + elids, + (k & 0x1 ? types : NULL), + (k & 0x2 ? lens : NULL)); + test_Compare(0, <=, r); + + numfound = r; + + test.Printf(_L("%d match(es)\n"), r); + + // Check that all returned element ids satisfy the conditions + TUint l; + for (l = 0; l < numfound; l++) + { + test_Assert( + (KTestFindSettingsPatternArgs[i].iMask & KTestFindSettingsPatternArgs[i].iPattern) == + (KTestFindSettingsPatternArgs[i].iMask & elids[l]), test.Printf(_L("!!%08x!!\n"), elids[l]) + ); + //Somehow the macro test_Compare consider TInt32 instead TUint32 + //as a result comparasion is done by this way: + //RTEST: (0x0 (0) < 0x80000000 (-2147483648)) == EFalse at line 1038 + //althought 0x80000000 > 0, with the signed form this number will be + //-2147483648. + //test_Compare(KTestFindSettingsPatternArgs[i].iAtId, <=, elids[l]); + } + + // Check that all elements that satisfy the conditions have been returned + SSettingC* setting; + TUint32 numsettings = 0; + for (setting = aRepository; setting < aRepository + aNumberOfSettings; setting++) + { + if ((setting->iName.iId.iCat == KTestCategories[j]) + && ((KTestFindSettingsPatternArgs[i].iMask & KTestFindSettingsPatternArgs[i].iPattern) == + (KTestFindSettingsPatternArgs[i].iMask & setting->iName.iId.iKey))) + { + for (l = 0; l < numfound; l++) + { + if (setting->iName.iId.iKey == elids[l]) + { + break; + } + } + test_Assert(l < numfound, test.Printf(_L("!!%08x!!\n"), elids[l])); + + // Check type and size returned + switch (setting->iName.iType) + { + case ETypeInt32: + case ETypeInt16: + case ETypeInt8: + case ETypeBool: + case ETypeUInt32: + case ETypeUInt16: + case ETypeUInt8: + case ETypeLinAddr: + if (k & 0x1) + { + test_Equal(setting->iName.iType, types[l]); + } + if (k & 0x2) + { + test_Equal(0, lens[l]); + } + break; + // Fall-through + case ETypeBinData: + case ETypeText8: + case ETypeArrayInt32: + case ETypeArrayUInt32: + case ETypeInt64: + case ETypeUInt64: + if (k & 0x1) + { + test_Equal(setting->iName.iType, types[l]); + } + if (k & 0x2) + { + test_Equal(setting->iName.iLen, lens[l]); + } + break; + default: + test(EFalse); + } + numsettings++; + } + } + test_Equal(numsettings, numfound); + } + } + } + + // Free memory + User::Free(elids); + User::Free(types); + User::Free(lens); + } + +void HcrSimApiNegative(const TInt aExpectedErrorCode, const TUint32 aCategory, const TUint32 aSettingId) + { + test.Next(_L("ApiNegative")); + test.Printf(_L("Expected error: %d\nSetting (%08x, %08x)\n"), aExpectedErrorCode, aCategory, aSettingId); + TSettingId id(aCategory, aSettingId); + TInt r; + { + TInt32 val; + r = HcrSimTest.GetInt(id, val); + test_Equal(aExpectedErrorCode, r); + } + { + TInt16 val; + r = HcrSimTest.GetInt(id, val); + test_Equal(aExpectedErrorCode, r); + } + { + TInt8 val; + r = HcrSimTest.GetInt(id, val); + test_Equal(aExpectedErrorCode, r); + } + { + TBool val; + r = HcrSimTest.GetBool(id, val); + test_Equal(aExpectedErrorCode, r); + } + { + TUint32 val; + r = HcrSimTest.GetUInt(id, val); + test_Equal(aExpectedErrorCode, r); + } + { + TUint16 val; + r = HcrSimTest.GetUInt(id, val); + test_Equal(aExpectedErrorCode, r); + } + { + TUint8 val; + r = HcrSimTest.GetUInt(id, val); + test_Equal(aExpectedErrorCode, r); + } + { + TLinAddr val; + r = HcrSimTest.GetLinAddr(id, val); + test_Equal(aExpectedErrorCode, r); + } + { + TBuf8 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 dval; + TText8* pval; + pval = (TText8*) User::Alloc(KMaxSettingLength); + test_NotNull(pval); + // + r = HcrSimTest.GetString(id, dval); + test_Equal(aExpectedErrorCode, r); + // + TUint16 actuallength; + r = HcrSimTest.GetString(id, KMaxSettingLength, pval, actuallength); + test_Equal(aExpectedErrorCode, r); + // + User::Free(pval); + } + { + TInt32* pval; + pval = (TInt32*) User::Alloc(KMaxSettingLength); + test_NotNull(pval); + // + TUint16 actuallength; + r = HcrSimTest.GetArray(id, KMaxSettingLength, pval, actuallength); + test_Equal(aExpectedErrorCode, r); + // + User::Free(pval); + } + { + TUint32* pval; + pval = (TUint32*) User::Alloc(KMaxSettingLength); + test_NotNull(pval); + // + TUint16 actuallength; + r = HcrSimTest.GetArray(id, KMaxSettingLength, pval, actuallength); + test_Equal(aExpectedErrorCode, r); + // + User::Free(pval); + } + { + TInt64 val; + r = HcrSimTest.GetInt(id, val); + test_Equal(aExpectedErrorCode, r); + } + { + TUint64 val; + r = HcrSimTest.GetUInt(id, val); + test_Equal(aExpectedErrorCode, r); + } + + { + TSettingType type = ETypeUndefined; + TUint16 len = 0; + TUint32 numfound = 0; + TElementId elid = 0; + + + // + r = HcrSimTest.GetTypeAndSize(id, type, len); + test_Equal(aExpectedErrorCode, r); + + // + r = HcrSimTest.FindNumSettingsInCategory(id.iCat); + if (aExpectedErrorCode == KErrNotFound) + { + test_Equal(0, r); + } + + // + r = HcrSimTest.FindSettings(id.iCat, 1, numfound, &elid, &type, &len); + if (aExpectedErrorCode == KErrNotFound) + { + test_Equal(0, r); + } + + // + r = HcrSimTest.FindSettings(id.iCat, 1, 0, 0, numfound, &elid, &type, &len); + if (aExpectedErrorCode == KErrNotFound) + { + test_Equal(0, r); + } + + } + { + SSettingId settingid; + settingid.iCat = id.iCat; + settingid.iKey = id.iKey; + + TInt32 val; + TInt err; + TSettingType type; + TInt i; + + for(i = 0; i < 4; ++i) + { + // test parameter combinations where aIds[], aValues[], aErrors[] are NULL + r = HcrSimTest.GetWordSettings(i, (i==1)?NULL:&settingid, (i==2)?NULL:&val, &type, (i==3)?NULL:&err); + if(r != KErrArgument) + { + test_Equal(aExpectedErrorCode, r); + } + } + } + + } + +void HcrSimTestApiTests(SSettingC* aRepository, TUint aNumberOfSettings) + { + if (aRepository && aNumberOfSettings > 0) + { + HcrSimGetSettings(aRepository, aNumberOfSettings); + HcrSimGetSettingsNegative(aRepository, aNumberOfSettings); + HcrSimSettingProperties(aRepository, aNumberOfSettings); + HcrSimMultipleGet(aRepository, aNumberOfSettings); + HcrSimNumSettingsInCategory(aRepository, aNumberOfSettings); + HcrSimFindSettingsCategory(aRepository, aNumberOfSettings); + HcrSimFindSettingsPattern(aRepository, aNumberOfSettings); + } + + HcrSimApiNegative(KErrNotFound, KTestInvalidCategory, KTestInvalidSettingId); + HcrSimApiNegative(KErrNotFound, KTestInvalidCategory, 1); + } + +void HcrPslTests(const TDesC& aDriver) + { + test.Next(_L("PSL tests")); test.Start(_L("Load Device Driver")); + test.Printf(_L("%S\n"), &aDriver); TInt r; - r = User::LoadLogicalDevice(KTestHcrSim); + r = User::LoadLogicalDevice(aDriver); if (r == KErrAlreadyExists) { test.Printf(_L("Unload Device Driver and load it again\n")); - r = User::FreeLogicalDevice(KTestHcrSim); + r = User::FreeLogicalDevice(aDriver); test_KErrNone(r); - r = User::LoadLogicalDevice(KTestHcrSim); + r = User::LoadLogicalDevice(aDriver); test_KErrNone(r); } else @@ -726,63 +1351,88 @@ } test.Next(_L("Open test channel")); - r = HcrSimTest.Open(); + 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); - HcrSimGetSettingsNotReady(); + test.End(); + } +void HcrSimTests(const TDesC& aDriver) + { + test.Next(_L("HCR Simulator tests")); + test.Start(_L("Load Device Driver")); + test.Printf(_L("%S\n"), &aDriver); + TInt r; + r = User::LoadLogicalDevice(aDriver); + if (r == KErrAlreadyExists) + { + test.Printf(_L("Unload Device Driver and load it again\n")); + r = User::FreeLogicalDevice(aDriver); + test_KErrNone(r); + r = User::LoadLogicalDevice(aDriver); + test_KErrNone(r); + } + else + { + test_KErrNone(r); + } + + test.Next(_L("Open test channel")); + r = HcrSimTest.Open(aDriver); + test_KErrNone(r); + HcrSimApiNegative(KErrNotReady, 1, 1); + test.Next(_L("Initialise HCR")); r = HcrSimTest.InitExtension(); test_KErrNone(r); test.Next(_L("Compiled")); test.Start(_L("Initialisation")); -#ifndef __WINS__ - _LIT8(KTestFileRepos, "filerepos.dat"); - _LIT8(KTestNandRepos, "nandrepos.dat"); - _LIT8(KTestCorrupt1, "corrupt1.dat"); - _LIT8(KTestCorrupt2, "corrupt2.dat"); - _LIT8(KTestEmpty, "empty.dat"); - _LIT8(KTestClearRepos, ""); - r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos); test_KErrNone(r); r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos); test_KErrNone(r); -#endif // __WINS__ - HcrSimGetSettings(SettingsList, sizeof(SettingsList) / sizeof(SSettingC)); - HcrSimGetSettingsNegative(SettingsList, sizeof(SettingsList) / sizeof(SSettingC)); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); - //HcrSimSettingProperties(SettingsList, sizeof(SettingsList) / sizeof(SSettingC)); - //HcrSimMultipleGet(SettingsList, sizeof(SettingsList) / sizeof(SSettingC)); + HcrSimTestApiTests(SettingsList, sizeof(SettingsList) / sizeof(SSettingC)); test.End(); -#ifndef __WINS__ test.Next(_L("Compiled+File")); test.Start(_L("Initialisation")); r = HcrSimTest.SwitchRepository(KTestFileRepos, HCRInternal::ECoreRepos); test_KErrNone(r); r = HcrSimTest.CheckIntegrity(); test_KErrNone(r); - HcrSimGetSettings(SettingsList2, sizeof(SettingsList2) / sizeof(SSettingC)); - HcrSimGetSettingsNegative(SettingsList2, sizeof(SettingsList2) / sizeof(SSettingC)); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); + 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); - HcrSimGetSettings(SettingsList3, sizeof(SettingsList3) / sizeof(SSettingC)); - HcrSimGetSettingsNegative(SettingsList3, sizeof(SettingsList3) / sizeof(SSettingC)); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); + HcrSimTestApiTests(SettingsList3, sizeof(SettingsList3) / sizeof(SSettingC)); test.End(); test.Next(_L("Compiled+Nand")); @@ -791,11 +1441,7 @@ test_KErrNone(r); r = HcrSimTest.CheckIntegrity(); test_KErrNone(r); - HcrSimGetSettings(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); - HcrSimGetSettingsNegative(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); + HcrSimTestApiTests(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); test.End(); test.Next(_L("Compiled+Empty+Nand")); @@ -804,53 +1450,37 @@ test_KErrNone(r); r = HcrSimTest.CheckIntegrity(); test_KErrNone(r); - HcrSimGetSettings(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); - HcrSimGetSettingsNegative(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); + HcrSimTestApiTests(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); test.End(); -#endif // __WINS__ // Reload device driver without a compiled repository this time test.Next(_L("Reload Device Driver")); HcrSimTest.Close(); - r = User::FreeLogicalDevice(KTestHcrSim); + r = User::FreeLogicalDevice(aDriver); test_KErrNone(r); - r = User::LoadLogicalDevice(KTestHcrSim); + r = User::LoadLogicalDevice(aDriver); test_KErrNone(r); - r = HcrSimTest.Open(); + r = HcrSimTest.Open(aDriver); test_KErrNone(r); r = HcrSimTest.InitExtension(ETestNullRepository); // *** The NULL Repository *** -#ifdef __WINS__ - test_Equal(KErrArgument, r); -#else 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); - HcrSimGetSettings(SettingsList7, sizeof(SettingsList7) / sizeof(SSettingC)); - HcrSimGetSettingsNegative(SettingsList7, sizeof(SettingsList7) / sizeof(SSettingC)); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); + 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); - HcrSimGetSettings(SettingsList6, sizeof(SettingsList6) / sizeof(SSettingC)); - HcrSimGetSettingsNegative(SettingsList6, sizeof(SettingsList6) / sizeof(SSettingC)); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); + HcrSimTestApiTests(SettingsList6, sizeof(SettingsList6) / sizeof(SSettingC)); test.End(); test.Next(_L("NULL+Nand")); @@ -859,26 +1489,20 @@ test_KErrNone(r); r = HcrSimTest.CheckIntegrity(); test_KErrNone(r); - HcrSimGetSettings(SettingsList5, sizeof(SettingsList5) / sizeof(SSettingC)); - HcrSimGetSettingsNegative(SettingsList5, sizeof(SettingsList5) / sizeof(SSettingC)); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); + HcrSimTestApiTests(SettingsList5, sizeof(SettingsList5) / sizeof(SSettingC)); test.End(); -#endif // __WINS__ test.Next(_L("Reload Device Driver")); HcrSimTest.Close(); - r = User::FreeLogicalDevice(KTestHcrSim); + r = User::FreeLogicalDevice(aDriver); test_KErrNone(r); - r = User::LoadLogicalDevice(KTestHcrSim); + r = User::LoadLogicalDevice(aDriver); test_KErrNone(r); - r = HcrSimTest.Open(); + r = HcrSimTest.Open(aDriver); test_KErrNone(r); r = HcrSimTest.InitExtension(ETestEmptyRepository); // *** The Empty Repository *** test_KErrNone(r); -#ifndef __WINS__ test.Next(_L("Empty+Nand")); test.Start(_L("Initialisation")); r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos); @@ -889,11 +1513,7 @@ test_KErrNone(r); r = HcrSimTest.CheckIntegrity(); test_KErrNone(r); - HcrSimGetSettings(SettingsList5, sizeof(SettingsList5) / sizeof(SSettingC)); - HcrSimGetSettingsNegative(SettingsList5, sizeof(SettingsList5) / sizeof(SSettingC)); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); + HcrSimTestApiTests(SettingsList5, sizeof(SettingsList5) / sizeof(SSettingC)); test.End(); test.Next(_L("Empty+File+Nand")); @@ -902,11 +1522,7 @@ test_KErrNone(r); r = HcrSimTest.CheckIntegrity(); test_KErrNone(r); - HcrSimGetSettings(SettingsList6, sizeof(SettingsList6) / sizeof(SSettingC)); - HcrSimGetSettingsNegative(SettingsList6, sizeof(SettingsList6) / sizeof(SSettingC)); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); + HcrSimTestApiTests(SettingsList6, sizeof(SettingsList6) / sizeof(SSettingC)); test.End(); test.Next(_L("Empty+File")); @@ -915,11 +1531,7 @@ test_KErrNone(r); r = HcrSimTest.CheckIntegrity(); test_KErrNone(r); - HcrSimGetSettings(SettingsList7, sizeof(SettingsList7) / sizeof(SSettingC)); - HcrSimGetSettingsNegative(SettingsList7, sizeof(SettingsList7) / sizeof(SSettingC)); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); + HcrSimTestApiTests(SettingsList7, sizeof(SettingsList7) / sizeof(SSettingC)); test.End(); test.Next(_L("No Repository (Empty)")); @@ -928,9 +1540,7 @@ test_KErrNone(r); r = HcrSimTest.CheckIntegrity(); test_KErrNone(r); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); + HcrSimTestApiTests(NULL, 0); test.End(); test.Next(_L("All Repositories Empty")); @@ -941,45 +1551,36 @@ test_KErrNone(r); r = HcrSimTest.CheckIntegrity(); test_KErrNone(r); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); + HcrSimTestApiTests(NULL, 0); test.End(); -#endif // __WINS__ test.Next(_L("Reload Device Driver")); HcrSimTest.Close(); - r = User::FreeLogicalDevice(KTestHcrSim); + r = User::FreeLogicalDevice(aDriver); test_KErrNone(r); - r = User::LoadLogicalDevice(KTestHcrSim); + r = User::LoadLogicalDevice(aDriver); test_KErrNone(r); - r = HcrSimTest.Open(); + r = HcrSimTest.Open(aDriver); test_KErrNone(r); r = HcrSimTest.InitExtension(ETestIgnoreCoreImgRepository); // *** Ignore Core Image Repository *** test_KErrNone(r); -#ifndef __WINS__ 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); - HcrSimGetSettings(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); - HcrSimGetSettingsNegative(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); - HcrSimGetSettingsNotFound(KTestInvalidCategory, KTestInvalidSettingId); - HcrSimGetSettingsNotFound(KTestInvalidCategory, 1); - HcrSimGetSettingsNotFound(1, KTestInvalidSettingId); + HcrSimTestApiTests(SettingsList4, sizeof(SettingsList4) / sizeof(SSettingC)); test.End(); -#endif // __WINS__ test.Next(_L("Reload Device Driver (Corrupt1)")); HcrSimTest.Close(); - r = User::FreeLogicalDevice(KTestHcrSim); + r = User::FreeLogicalDevice(aDriver); test_KErrNone(r); - r = User::LoadLogicalDevice(KTestHcrSim); + r = User::LoadLogicalDevice(aDriver); test_KErrNone(r); - r = HcrSimTest.Open(); + r = HcrSimTest.Open(aDriver); test_KErrNone(r); r = HcrSimTest.InitExtension(ETestCorruptRepository1); // *** Repository not ordered *** #ifdef _DEBUG @@ -990,11 +1591,11 @@ test.Next(_L("Reload Device Driver (Corrupt2)")); HcrSimTest.Close(); - r = User::FreeLogicalDevice(KTestHcrSim); + r = User::FreeLogicalDevice(aDriver); test_KErrNone(r); - r = User::LoadLogicalDevice(KTestHcrSim); + r = User::LoadLogicalDevice(aDriver); test_KErrNone(r); - r = HcrSimTest.Open(); + r = HcrSimTest.Open(aDriver); test_KErrNone(r); r = HcrSimTest.InitExtension(ETestCorruptRepository2); // *** Repository with duplicates *** #ifdef _DEBUG @@ -1003,14 +1604,28 @@ test_KErrNone(r); #endif // _DEBUG -#ifndef __WINS__ + 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(KTestHcrSim); + r = User::FreeLogicalDevice(aDriver); test_KErrNone(r); - r = User::LoadLogicalDevice(KTestHcrSim); + r = User::LoadLogicalDevice(aDriver); test_KErrNone(r); - r = HcrSimTest.Open(); + r = HcrSimTest.Open(aDriver); test_KErrNone(r); r = HcrSimTest.InitExtension(); // *** Default Repository *** test_KErrNone(r); @@ -1050,22 +1665,525 @@ r = HcrSimTest.CheckIntegrity(); test_Equal(KErrAlreadyExists, r); test.End(); -#endif // __WINS__ test.Next(_L("Close test channel and unload device driver")); HcrSimTest.Close(); - r = User::FreeLogicalDevice(KTestHcrSim); + r = User::FreeLogicalDevice(aDriver); test_KErrNone(r); test.End(); } +void RomHeaderTests() + { + test.Next(_L("Rom Header")); +#ifdef __WINS__ + test.Printf(_L("Not available on the emulator.\n")); +#else + const TRomHeader* romheader = (TRomHeader*) UserSvr::RomHeaderAddress(); + test.Printf(_L("HCR File Address: %08x\n"), romheader->iHcrFileAddress); + test(romheader->iHcrFileAddress); + if (romheader->iPageableRomStart) + { + // If this is a paged ROM, HCR file must be in the unpaged area + test_Compare(romheader->iRomBase + romheader->iPageableRomStart, >, romheader->iHcrFileAddress); + } +#endif // __WINS__ + } + +void HcrRealSettingDiscovery() + { + test.Next(_L("Setting Discovery")); + TInt r; + TCategoryUid cat; + test.Printf(_L("Category Element Type Len Value\n")); + test.Printf(_L("--------------------------------------------------\n")); + for (cat = KHCRUID_ALLOCATED_MIN; cat <= KHCRUID_ALLOCATED_MAX; cat++) + { + TInt nosettings; + nosettings = HcrSimTest.FindNumSettingsInCategory(cat); + test_Compare(0, <=, nosettings); + if (nosettings > 0) + { + TUint32 numfound; + TElementId* elids; + TSettingType* types; + TUint16* lens; + elids = (TElementId*) User::Alloc(nosettings * sizeof(TElementId)); + test_NotNull(elids); + types = (TSettingType*) User::Alloc(nosettings * sizeof(TSettingType)); + test_NotNull(types); + lens = (TUint16*) User::Alloc(nosettings * sizeof(TUint16)); + test_NotNull(lens); + r = HcrSimTest.FindSettings(cat, nosettings, numfound, elids, types, lens); + test_Equal(nosettings, r); + test_Equal(nosettings, numfound); + TInt i; + for (i = 0; i < nosettings; i++) + { + TSettingId id(cat, *(elids + i)); + test.Printf(_L("%08x %08x %08x %04x "), cat, *(elids + i), *(types + i), *(lens + i)); + switch (*(types + i)) + { + case ETypeInt32: + { + TInt32 val; + r = HcrSimTest.GetInt(id, val); + test_KErrNone(r); + test.Printf(_L("%08x"), val); + break; + } + case ETypeInt16: + { + TInt16 val; + r = HcrSimTest.GetInt(id, val); + test_KErrNone(r); + test.Printf(_L("%04x"), val); + break; + } + case ETypeInt8: + { + TInt8 val; + r = HcrSimTest.GetInt(id, val); + test_KErrNone(r); + test.Printf(_L("%02x"), val); + break; + } + case ETypeBool: + { + TBool val; + r = HcrSimTest.GetBool(id, val); + test_KErrNone(r); + test.Printf(_L("%b"), val ? 1 : 0); + break; + } + case ETypeUInt32: + { + TUint32 val; + r = HcrSimTest.GetUInt(id, val); + test_KErrNone(r); + test.Printf(_L("%08x"), val); + break; + } + case ETypeUInt16: + { + TUint16 val; + r = HcrSimTest.GetUInt(id, val); + test_KErrNone(r); + test.Printf(_L("%04x"), val); + break; + } + case ETypeUInt8: + { + TUint8 val; + r = HcrSimTest.GetUInt(id, val); + test_KErrNone(r); + test.Printf(_L("%02x"), val); + break; + } + case ETypeLinAddr: + { + TLinAddr val; + r = HcrSimTest.GetLinAddr(id, val); + test_KErrNone(r); + test.Printf(_L("%08x"), val); + break; + } + case ETypeBinData: + { + TBuf8 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 dval; + TText8* pval; + pval = (TText8*) User::Alloc(*(lens + i)); + test_NotNull(pval); + // + r = HcrSimTest.GetString(id, dval); + test_KErrNone(r); + test_Equal(*(lens + i), dval.Length()); + // + TUint16 actuallength; + r = HcrSimTest.GetString(id, *(lens + i), pval, actuallength); + test_KErrNone(r); + test_Equal(*(lens + i), actuallength); + // + TInt j; + for (j = 0; j < 15 && j < dval.Length(); j++) + { + test.Printf(_L("%c "), dval[j]); + } + // + User::Free(pval); + break; + } + case ETypeArrayInt32: + { + TInt32* pval; + pval = (TInt32*) User::Alloc(*(lens + i)); + test_NotNull(pval); + // + TUint16 actuallength; + r = HcrSimTest.GetArray(id, *(lens + i), pval, actuallength); + test_KErrNone(r); + // + test_Equal(*(lens + i), actuallength); + // + TUint j; + for (j = 0; j < 2 && j < actuallength / sizeof(TInt32); j++) + { + test.Printf(_L("%08x "), pval[0]); + } + // + User::Free(pval); + break; + } + case ETypeArrayUInt32: + { + TUint32* pval; + pval = (TUint32*) User::Alloc(*(lens + i)); + test_NotNull(pval); + // + TUint16 actuallength; + r = HcrSimTest.GetArray(id, *(lens + i), pval, actuallength); + test_KErrNone(r); + // + TUint j; + for (j = 0; j < 2 && j < actuallength / sizeof(TUint32); j++) + { + test.Printf(_L("%08x "), pval[0]); + } + // + test_Equal(*(lens + i), actuallength); + User::Free(pval); + break; + } + case ETypeInt64: + { + TInt64 val; + r = HcrSimTest.GetInt(id, val); + test_KErrNone(r); + test.Printf(_L("%016lx"), val); + + break; + } + case ETypeUInt64: + { + TUint64 val; + r = HcrSimTest.GetUInt(id, val); + test_KErrNone(r); + test.Printf(_L("%016lx"), val); + break; + } + default: + test(EFalse); + } + test.Printf(_L("\n")); + } + User::Free(elids); + User::Free(types); + User::Free(lens); + } + } + } +void HcrRealRetrieveKernelExtensionTestResults() + { + test.Next(_L("Retrieve kernel extension test results")); + TInt r; + TInt kextline; + TInt kexterror; + r = HcrSimTest.GetInitExtensionTestResults(kextline, kexterror); + test_KErrNone(r); + if (kextline == -1) + { + test.Printf(_L("Test not run\n")); + } + else if (kextline == 0) + { + test.Printf(_L("Test passed\n")); + } + else + { + test.Printf(_L("Test kernel extension error at line %d (error %d)\n"), kextline, kexterror); + test(EFalse); + } + } + +void HcrRealTests(const TDesC& aDriver) + { + test.Next(_L("HCR real tests")); + test.Start(_L("Load LDD")); + test.Printf(_L("%S\n"), &aDriver); + TInt r; + r = User::LoadLogicalDevice(aDriver); + if (r == KErrNotFound) + { + test.Printf(_L("%S not found. Skipping tests.\n"), &aDriver); + } + else + { + if (r == KErrAlreadyExists) + { + test.Printf(_L("Unload Device Driver and load it again\n")); + r = User::FreeLogicalDevice(aDriver); + test_KErrNone(r); + r = User::LoadLogicalDevice(aDriver); + } + test_KErrNone(r); + r = HcrSimTest.Open(aDriver); + test_KErrNone(r); + // + HcrRealRetrieveKernelExtensionTestResults(); + HcrRealSettingDiscovery(); + // + test.Next(_L("Close LDD")); + HcrSimTest.Close(); + r = User::FreeLogicalDevice(aDriver); + test_KErrNone(r); + } + test.End(); + } + +void HcrSimBenchmarkTests(const TDesC& aDriver) + { + test.Next(_L("Simulated HCR Benchmark")); + test.Start(_L("Initialisation")); + test.Printf(_L("%S\n"), &aDriver); + TInt r; + r = User::LoadLogicalDevice(aDriver); + if (r == KErrAlreadyExists) + { + test.Printf(_L("Unload Device Driver and load it again\n")); + r = User::FreeLogicalDevice(aDriver); + test_KErrNone(r); + r = User::LoadLogicalDevice(aDriver); + test_KErrNone(r); + } + else + { + test_KErrNone(r); + } + r = HcrSimTest.Open(aDriver); + test_KErrNone(r); + r = HcrSimTest.InitExtension(); + test_KErrNone(r); + r = HcrSimTest.CheckIntegrity(); + test_KErrNone(r); + + test.Next(_L("Get Setting")); + // Timings in ms + TUint32 int1 = 0; + TUint32 int1000 = 0; + TUint32 array1 = 0; + TUint32 array1000 = 0; + TUint32 des1 = 0; + TUint32 des1000 = 0; + TUint32 fns = 0; + TUint32 fs = 0; + TUint32 gts = 0; + TUint32 gws = 0; + _LIT(KTestBenchLine, "%-6d %-6d %-6d %-6d %-6d %-6d %-6d %-6d %-6d %-6d\n"); + test.Printf(_L("HCR Int1 Int1000 Arr1 Arr1000 Des1 Des1000 FNS FS GTS GWS\n")); + // Default configuration + TSettingId idint1(1, 1); + TSettingId idstring1(KTestCategories[2], 0x6000); + test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1, int1)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1, array1)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1, des1)); + test.Printf(_L("C?? ")); + test.Printf(KTestBenchLine, int1, int1000, array1, array1000, des1, des1000, fns, fs, gts, gws); + + r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::ECoreRepos); + test_KErrNone(r); + r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos); + test_KErrNone(r); + r = HcrSimTest.CheckIntegrity(); + test_KErrNone(r); + test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1, int1)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1, array1)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1, des1)); + test.Printf(_L("C__ ")); + test.Printf(KTestBenchLine, int1, int1000, array1, array1000, des1, des1000, fns, fs, gts, gws); + // + TSettingId idint1000(KTestBenchmarkCategoryId, 1000); + TSettingId idstring1000(KTestBenchmarkCategoryId, 1001); + r = HcrSimTest.SwitchRepository(KTestMegaLarge1, HCRInternal::ECoreRepos); + test_KErrNone(r); + r = HcrSimTest.CheckIntegrity(); + test_KErrNone(r); + test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1, int1)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1000, int1000)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1, array1)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1000, array1000)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1, des1)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1000, des1000)); + + test_Equal(KTestBenchmarkNumberOfSettingsInCategory, HcrSimTest.BenchmarkFindNumSettingsInCategory(KTestBenchmarkCategoryId, fns)); + test_Equal(KTestBenchmarkNumberOfSettingsInCategory, HcrSimTest.BenchmarkFindSettings(KTestBenchmarkCategoryId, fs)); + test_KErrNone(HcrSimTest.BenchmarkGetTypeAndSize(idstring1000, gts)); + test_Equal(KTestBenchmarkNumberOfSettingsInCategory - 1, HcrSimTest.BenchmarkGetWordSettings(KTestBenchmarkCategoryId, gws)); + + test.Printf(_L("CF_ ")); + test.Printf(KTestBenchLine, int1, int1000, array1, array1000, des1, des1000, fns, fs, gts, gws); + // + r = HcrSimTest.SwitchRepository(KTestMegaLarge2, HCRInternal::EOverrideRepos); + test_KErrNone(r); + r = HcrSimTest.CheckIntegrity(); + test_KErrNone(r); + test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1, int1)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1000, int1000)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1, array1)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1000, array1000)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1, des1)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1000, des1000)); + + test_Equal(KTestBenchmarkNumberOfSettingsInCategory, HcrSimTest.BenchmarkFindNumSettingsInCategory(KTestBenchmarkCategoryId, fns)); + test_Equal(KTestBenchmarkNumberOfSettingsInCategory, HcrSimTest.BenchmarkFindSettings(KTestBenchmarkCategoryId, fs)); + test_KErrNone(HcrSimTest.BenchmarkGetTypeAndSize(idstring1000, gts)); + test_Equal(KTestBenchmarkNumberOfSettingsInCategory - 1, HcrSimTest.BenchmarkGetWordSettings(KTestBenchmarkCategoryId, gws)); + + test.Printf(_L("CFN ")); + test.Printf(KTestBenchLine, int1, int1000, array1, array1000, des1, des1000, fns, fs, gts, gws); + // + r = HcrSimTest.SwitchRepository(KTestClearRepos, HCRInternal::EOverrideRepos); + test_KErrNone(r); + r = HcrSimTest.CheckIntegrity(); + test_KErrNone(r); + test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1, int1)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingInt(idint1000, int1000)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1, array1)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingArray(idstring1000, array1000)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1, des1)); + test_KErrNone(HcrSimTest.BenchmarkGetSettingDes(idstring1000, des1000)); + + test_Equal(KTestBenchmarkNumberOfSettingsInCategory, HcrSimTest.BenchmarkFindNumSettingsInCategory(KTestBenchmarkCategoryId, fns)); + test_Equal(KTestBenchmarkNumberOfSettingsInCategory, HcrSimTest.BenchmarkFindSettings(KTestBenchmarkCategoryId, fs)); + test_KErrNone(HcrSimTest.BenchmarkGetTypeAndSize(idstring1000, gts)); + test_Equal(KTestBenchmarkNumberOfSettingsInCategory - 1, HcrSimTest.BenchmarkGetWordSettings(KTestBenchmarkCategoryId, gws)); + + test.Printf(_L("C_N ")); + test.Printf(KTestBenchLine, int1, int1000, array1, array1000, des1, des1000, fns, fs, gts, gws); + + test.Next(_L("Unload LDD")); + HcrSimTest.Close(); + r = User::FreeLogicalDevice(aDriver); + test_KErrNone(r); + test.End(); + } + +void HcrRealBenchmarkTests(const TDesC& aDriver) + { + TInt r; + test.Next(_L("Real HCR Benchmark")); + test.Start(_L("Initialisation")); + test.Printf(_L("%S\n"), &aDriver); + r = User::LoadLogicalDevice(aDriver); + if (r == KErrNotFound) + { + test.Printf(_L("%S not found. Skipping tests.\n"), &aDriver); + } + else + { + if (r == KErrAlreadyExists) + { + test.Printf(_L("Unload Device Driver and load it again\n")); + r = User::FreeLogicalDevice(aDriver); + test_KErrNone(r); + r = User::LoadLogicalDevice(aDriver); + } + test_KErrNone(r); + r = HcrSimTest.Open(aDriver); + test_KErrNone(r); + // + test.Next(_L("Close LDD")); + HcrSimTest.Close(); + r = User::FreeLogicalDevice(aDriver); + test_KErrNone(r); + } + test.End(); + } + GLDEF_C TInt E32Main() { __UHEAP_MARK; test.Title(); test.Start(_L("HCR Test Suite")); - HcrSimTests(); + + + + //Order the the test lists in descend(the setting with the smallest + //setting Id is first) + TLinearOrder order(CompareEntries); + //Build the ordered ids arrays + RArray rSettingsList(sizeof(SSettingC), SettingsList, + sizeof(SettingsList)/sizeof(SettingsList[0])); + + rSettingsList.Sort(order); + + RArray rSettingsList2(sizeof(SSettingC), SettingsList2, + sizeof(SettingsList2)/sizeof(SettingsList2[0])); + rSettingsList2.Sort(order); + + RArray rSettingsList3(sizeof(SSettingC), SettingsList3, + sizeof(SettingsList3)/sizeof(SettingsList3[0])); + rSettingsList3.Sort(order); + + RArray rSettingsList4(sizeof(SSettingC), SettingsList4, + sizeof(SettingsList4)/sizeof(SettingsList4[0])); + rSettingsList4.Sort(order); + + RArray rSettingsList5(sizeof(SSettingC), SettingsList5, + sizeof(SettingsList5)/sizeof(SettingsList5[0])); + rSettingsList5.Sort(order); + + RArray rSettingsList6(sizeof(SSettingC), SettingsList6, + sizeof(SettingsList6)/sizeof(SettingsList6[0])); + rSettingsList6.Sort(order); + + RArray rSettingsList7(sizeof(SSettingC), SettingsList7, + sizeof(SettingsList7)/sizeof(SettingsList7[0])); + rSettingsList7.Sort(order); + + + //Functional API tests + RomHeaderTests(); + HcrRealTests(KTestHcrRealOwn); + HcrRealTests(KTestHcrRealClient); + HcrPslTests(KTestHcrSimOwn); + HcrPslTests(KTestHcrSimClient); + HcrSimTests(KTestHcrSimOwn); + HcrSimTests(KTestHcrSimClient); + + + //Benchmark tests + HcrSimBenchmarkTests(KTestHcrSimOwn); + HcrSimBenchmarkTests(KTestHcrSimClient); + HcrRealBenchmarkTests(KTestHcrRealOwn); + HcrRealBenchmarkTests(KTestHcrRealClient); + test.End(); test.Close();