diff -r 0bf4040442f9 -r 46fffbe7b5a7 kerneltest/e32test/hcr/d_hcrut.cpp --- a/kerneltest/e32test/hcr/d_hcrut.cpp Fri Jan 22 11:03:55 2010 +0200 +++ b/kerneltest/e32test/hcr/d_hcrut.cpp Tue Jan 26 13:13:38 2010 +0200 @@ -24,18 +24,18 @@ #include #include #include "d_hcrut.h" - +#include "hcr_hai.h" #include "hcr_pil.h" #include - - +#define TEST_MEMGET(s, d, l) kumemget(d, s, l) +#define TEST_MEMPUT(d, s, l) kumemput(d, s, l) +#include "HcrImageData_102400.h" // -- CLASSES ----------------------------------------------------------------- - class DHcrTestFactory : public DLogicalDevice { public: @@ -83,7 +83,11 @@ HCR::TRepository* GetCoreImgRepos(); HCR::TRepository* GetOverrideImgRepos(); + HCR::MVariant* GetVariant() {return iHcrInt->iVariant;}; TInt SwitchRepository(const TText * aFileName, const HCR::HCRInternal::TReposId aId=HCR::HCRInternal::ECoreRepos); + + TInt CheckIntegrity(void); + TInt FindSetting(const TSettingId& aId, TSettingType aType, TSettingRef& aSetting); public: @@ -128,6 +132,20 @@ NKern::ThreadLeaveCS(); return retVal; } + + +TInt HCR::HCRInternalTestObserver::CheckIntegrity(void) + { + TInt retVal = iHcrInt->CheckIntegrity(); + return retVal; + } + +TInt HCR::HCRInternalTestObserver::FindSetting(const TSettingId& aId, TSettingType aType, TSettingRef& aSetting) + { + TInt retVal = iHcrInt->FindSetting( aId, aType, aSetting); + return retVal; + } + // -- GLOBALS ----------------------------------------------------------------- // @@ -195,12 +213,10 @@ return KErrNone; } -TInt DHcrTestChannel::Request(TInt aReqNo, TAny*, TAny*) +TInt DHcrTestChannel::Request(TInt aReqNo, TAny* a1, TAny* /*a2*/ ) { HCR_FUNC("DHcrTestChannel::Request"); - - switch(aReqNo) { @@ -216,6 +232,118 @@ case RHcrTest::ECtrlGetWordSetting: { + TAny* args[3]; + TEST_MEMGET(a1, args, sizeof(args)); + + HCR::TCategoryUid category = (HCR::TCategoryUid) args[0]; + + HCR::TElementId key = (HCR::TElementId) args[1]; + + TInt type = (TInt) args[2]; + + const TText * fileInSysBinName = (const TText *)"filerepos.dat"; + TInt err = gObserver.SwitchRepository(fileInSysBinName, HCR::HCRInternal::ECoreRepos); + if (err != KErrNone) + HCR_TRACE_RETURN(err); + + // Negative tests on HCR::TRepositoryFile; aNum will be 0 + HCR::TRepository* repos = gObserver.GetCoreImgRepos();; + __NK_ASSERT_DEBUG(repos != NULL); + + + HCR::SSettingId* ids[1];// = new HCR::SSettingId*[1]; + + TInt32* vals[1]; + TInt* errs[1]; + HCR::TSettingType* types[1]; + + NKern::ThreadEnterCS(); + ids[0] = new HCR::SSettingId(); + vals[0] = new TInt32(); + errs[0] = new TInt(); + types[0] = new HCR::TSettingType(); + + if(ids[0] == NULL || vals[0] == NULL || errs[0] == NULL || types[0] == NULL) + { + delete ids[0]; + delete vals[0]; + delete errs[0]; + delete types[0]; + NKern::ThreadLeaveCS(); + HCR_TRACE_RETURN(KErrNoMemory); + } + + ids[0]->iCat = category; + ids[0]->iKey = key; + + // Negative tests on HCR::TRepositoryFile; aNum will be 0 + TInt r = repos->GetWordSettings(0, ids, vals, types, errs); + // only expected errors are KErrNotFound or KErrNone + // thest if there is other error; if yes fail the test + if(r != KErrNotFound && r != KErrNone && r < KErrNone) + { + delete ids[0]; + delete vals[0]; + delete errs[0]; + delete types[0]; + NKern::ThreadLeaveCS(); + HCR_TRACE_RETURN(r); + } + + // Negative testing on HCR::TRepositoryFile; try to get words for large value + if(type > HCR::ETypeLinAddr) + { + r = repos->GetWordSettings(1, ids, vals, types, errs); + if(r != KErrArgument && r != KErrNotFound && r < KErrNone) + { + delete ids[0]; + delete vals[0]; + delete errs[0]; + delete types[0]; + NKern::ThreadLeaveCS(); + HCR_TRACE_RETURN(r); + } + } + + HCR::TRepositoryCompiled* compiledRepos = reinterpret_cast(gObserver.GetVariantImgRepos()); + __NK_ASSERT_DEBUG(compiledRepos != NULL); + + ids[0]->iCat = KHCRUID_TestCategory1; + ids[0]->iKey = key; + + // Negative tests on HCR::TRepositoryCompiled; aNum will be 0 + r = compiledRepos->GetWordSettings(0, ids, vals, types, errs); + if(r != KErrNotFound && r != KErrNone && r < KErrNone) + { + delete ids[0]; + delete vals[0]; + delete errs[0]; + delete types[0]; + NKern::ThreadLeaveCS(); + HCR_TRACE_RETURN(r); + } + + // Negative testing on HCR::TRepositoryFile; try to get words for large value + if(type > HCR::ETypeLinAddr) + { + r = compiledRepos->GetWordSettings(1, ids, vals, types, errs); + if(r != KErrArgument && r != KErrNotFound && r < KErrNone) + { + delete ids[0]; + delete vals[0]; + delete errs[0]; + delete types[0]; + NKern::ThreadLeaveCS(); + HCR_TRACE_RETURN(r); + } + } + + delete ids[0]; + delete vals[0]; + delete errs[0]; + delete types[0]; + NKern::ThreadLeaveCS(); + return KErrNone; } @@ -303,10 +431,210 @@ return err; } - case RHcrTest::ECtrlFreePhyscialRam: + case RHcrTest::ECtrlNegativeTestsLargeValues: + { + //Test that HCR::TRepositoryCompiled::GetLargeValue & HCR::TRepositoryFile::GetLargeValue return KErrArgument + TAny* args[1]; + TEST_MEMGET(a1, args, sizeof(args)); + // Retrieve structures from client + TInt expectedError = (TUint) args[0]; + + const TText * fileInSysBinName = (const TText *)"filerepos.dat"; + TInt err = gObserver.SwitchRepository(fileInSysBinName, HCR::HCRInternal::ECoreRepos); + if (err != KErrNone) + HCR_TRACE_RETURN(err); + + // Do test for HCR::TRepositoryFile + HCR::TRepository* repos = gObserver.GetCoreImgRepos();; + __NK_ASSERT_DEBUG(repos != NULL); + + HCR::UValueLarge value; + HCR::TSettingRef ref(0,0); + HCR::TSettingId id(1,1); //word setting value in repository + err = repos->FindSetting(id, ref); + if(err == KErrNone) + { + err = repos->GetLargeValue(ref, value); + if(err != expectedError) + { + HCR_TRACE_RETURN(err); + } + } + + //Do test for HCR::TRepositoryCompiled + HCR::TRepositoryCompiled* compiledRepos = reinterpret_cast(gObserver.GetVariantImgRepos()); + if (compiledRepos == 0) + { + HCR_TRACE_RETURN(KErrGeneral); + } + + id = HCR::TSettingId(KHCRUID_TestCategory1,1); + err = compiledRepos->FindSetting(id, ref); + if(err == KErrNone) + { + err = compiledRepos->GetLargeValue(ref, value); + if(err != expectedError) + { + HCR_TRACE_RETURN(err); + } + } + + return KErrNone; + } + + + case RHcrTest::ECtrlCheckOverrideReposIntegrity: + { + HCR::TRepository* overrideRepos = gObserver.GetOverrideImgRepos(); // Shadowed SMR/HCR + TInt err = KErrNone; + + if( 0 != overrideRepos ) + { + err = overrideRepos->CheckIntegrity(); + + } + return err; + } + + case RHcrTest::ECtrlCheckOverrideRepos102400Content: { - return KErrNone; + HCR::TRepository* overrideRepos = gObserver.GetOverrideImgRepos(); // Shadowed SMR/HCR + TInt err = KErrNone; + + if( 0 != overrideRepos ) + { + for( TInt index = 0; index < itemsSize; ++index) + { + HCR::TSettingId id(items[index].iCategoryUID, items[index].iElementID); + HCR_TRACE3("--- index:%5d, iCategoryUID:0x%08x, iElementID:0x%08x" + , index + , items[index].iCategoryUID + , items[index].iElementID + ); + HCR::TSettingRef val(overrideRepos, 0); + HCR::TSettingType type = (HCR::TSettingType)items[index].iType; + TInt r = gObserver.FindSetting(id, type, val); + if( r != KErrNone) + { + err = KErrNotFound; + break; + } + HCR::UValueWord valueWord; + r = overrideRepos->GetValue(val, valueWord); + HCR_TRACE1("--- value:0x%08x", valueWord.iUInt32); + if( valueWord.iUInt32 != items[index].iValue) + { + err = KErrNotFound; + break; + } + } + } + return err; } + + case RHcrTest::ECtrlSwitchFileRepository: + { + TInt r; + TAny* args[2]; + TEST_MEMGET(a1, args, sizeof(args)); + const TText* fileRepName = (TText*) args[0]; + + r = gObserver.SwitchRepository(fileRepName, HCR::HCRInternal::ECoreRepos); + if (r != KErrNone) + { + HCR_TRACE_RETURN(r); + } + else + return r; + } + + case RHcrTest::ECtrlCompiledFindSettingsInCategory: + { + TInt r = 0; + //Do test for HCR::TRepositoryCompiled + TAny* args[3]; + + + //It's a pre-condition to enter critical section before + //kernel memory allocation + NKern::ThreadEnterCS(); + TInt32* pFirst = new TInt32; + TInt32* pLast = new TInt32; + //We've done with allocation, exit CS + NKern::ThreadLeaveCS(); + + if(!pFirst || !pLast) + { + HCR_TRACE_RETURN(KErrNoMemory); + } + + TEST_MEMGET(a1, args, sizeof(args)); + HCR::TCategoryUid catUid = (HCR::TCategoryUid)args[0]; + + + HCR::TRepositoryCompiled* compiledRepos = + reinterpret_cast(gObserver.GetVariantImgRepos()); + if (compiledRepos == 0) + { + HCR_TRACE_RETURN(KErrGeneral); + } + + //This function return the result of operation r and first element and + //last element in the category written back to the user side test code + //variable referenced by pFirst and pLast pointers + r = compiledRepos->FindNumSettingsInCategory(catUid, + *pFirst, *pLast); + + TEST_MEMPUT(args[1], pFirst, sizeof(TInt32)); + TEST_MEMPUT(args[2], pLast, sizeof(TInt32)); + + if(r < 0) + {HCR_TRACE_RETURN(r);} + else + return r; + } + + case RHcrTest::ECtrlFileFindSettingsInCategory: + { + TInt r; + TAny* args[3]; + TEST_MEMGET(a1, args, sizeof(args)); + HCR::TCategoryUid catUid = (HCR::TCategoryUid)args[0]; + + //It's a pre-condition to enter critical section before + //kernel memory allocation + NKern::ThreadEnterCS(); + TInt32* pFirst = new TInt32; + TInt32* pLast = new TInt32; + //We've done with allocation, exit CS + NKern::ThreadLeaveCS(); + + if(!pFirst || !pLast) + { + HCR_TRACE_RETURN(KErrNoMemory); + } + + + // Do test for HCR::TRepositoryFile + HCR::TRepository* repos = gObserver.GetCoreImgRepos(); + __NK_ASSERT_DEBUG(repos != NULL); + + //This function return the result of operation r and first element and + //last element in the category written back to the user side test code + //variable referenced by pFirst and pLast pointers + r = repos->FindNumSettingsInCategory(catUid, + *pFirst, *pLast); + + TEST_MEMPUT(args[1], pFirst, sizeof(TInt32)); + TEST_MEMPUT(args[2], pLast, sizeof(TInt32)); + + if(r < 0) + {HCR_TRACE_RETURN(r);} + else + return r; + } + + default: break; @@ -322,16 +650,23 @@ DECLARE_STANDARD_LDD() { HCR_FUNC("D_HCR_DECLARE_STANDARD_LDD"); - + + // Try to initialise without a varian; KErrGeneral error should be returned + new(&gTestHcrInt) HCR::HCRInternal(NULL); + TInt err = gTestHcrInt.Initialise(); + if (err != KErrGeneral) + return 0; + + // Taken from HCR_PIL.CPP InitExtension() method HCR::MVariant* varPtr = CreateHCRVariant(); if (varPtr==0) return 0; - + new(&gTestHcrInt) HCR::HCRInternal(varPtr); - - TInt err = gTestHcrInt.Initialise(); + + err = gTestHcrInt.Initialise(); if (err != KErrNone) return 0;