86 	HCR::MVariant* GetVariant() {return iHcrInt->iVariant;};

    88 	    

    89 	TInt CheckIntegrity(void);

    90 	TInt FindSetting(const TSettingId& aId, TSettingType aType, TSettingRef& aSetting);

   135     

   136     

   137 TInt HCR::HCRInternalTestObserver::CheckIntegrity(void)

   138     {

   139     TInt retVal = iHcrInt->CheckIntegrity();

   140     return retVal;    

   141     }

   142     

   143 TInt HCR::HCRInternalTestObserver::FindSetting(const TSettingId& aId, TSettingType aType, TSettingRef& aSetting)

   144     {

   145     TInt retVal = iHcrInt->FindSetting( aId, aType, aSetting);

   146     return retVal;

   147     }

   148     

   235 		TAny* args[3];

   236 		TEST_MEMGET(a1, args, sizeof(args));

   237 

   238 		HCR::TCategoryUid category = (HCR::TCategoryUid) args[0];

   239     

   240 		HCR::TElementId key = (HCR::TElementId) args[1];

   241 

   242 		TInt type = (TInt) args[2];

   243 

   244 		const TText * fileInSysBinName = (const TText *)"filerepos.dat";

   245 		TInt err = gObserver.SwitchRepository(fileInSysBinName, HCR::HCRInternal::ECoreRepos);

   246 		if (err != KErrNone)

   247              HCR_TRACE_RETURN(err);

   248 

   249 		// Negative tests on HCR::TRepositoryFile; aNum will be 0

   250 		HCR::TRepository* repos = gObserver.GetCoreImgRepos();;

   251 		__NK_ASSERT_DEBUG(repos != NULL);

   252 

   253 

   254 		HCR::SSettingId* ids[1];// = new HCR::SSettingId*[1];

   255 

   256 		TInt32* vals[1];

   257 		TInt* errs[1];

   258 		HCR::TSettingType* types[1];

   259 		

   260 		NKern::ThreadEnterCS();

   261 		ids[0] = new HCR::SSettingId();

   262 		vals[0] = new TInt32();

   263 		errs[0] = new TInt();

   264 		types[0] = new HCR::TSettingType();

   265 

   266 		if(ids[0] == NULL || vals[0] == NULL || errs[0] == NULL || types[0] == NULL) 

   267 			{

   268 			delete ids[0];

   269 			delete vals[0];

   270 			delete errs[0];

   271 			delete types[0];

   272 			NKern::ThreadLeaveCS();

   273 			HCR_TRACE_RETURN(KErrNoMemory);

   274 			}

   275 

   276 		ids[0]->iCat = category;

   277 		ids[0]->iKey = key;

   278 

   279 		// Negative tests on HCR::TRepositoryFile; aNum will be 0

   280 		TInt r = repos->GetWordSettings(0, ids, vals, types, errs);

   281 		// only expected errors are KErrNotFound or KErrNone

   282 		// thest if there is other error; if yes fail the test

   283 		if(r != KErrNotFound && r != KErrNone && r < KErrNone)

   284 			{

   285 			delete ids[0];

   286 			delete vals[0];

   287 			delete errs[0];

   288 			delete types[0];

   289 			NKern::ThreadLeaveCS();

   290 			HCR_TRACE_RETURN(r);

   291 			}

   292 

   293 		// Negative testing on HCR::TRepositoryFile; try to get words for large value

   294 		if(type > HCR::ETypeLinAddr)

   295 			{

   296 			r = repos->GetWordSettings(1, ids, vals, types, errs);

   297 			if(r != KErrArgument && r != KErrNotFound && r < KErrNone)

   298 				{

   299 				delete ids[0];

   300 				delete vals[0];

   301 				delete errs[0];

   302 				delete types[0];

   303 				NKern::ThreadLeaveCS();

   304 				HCR_TRACE_RETURN(r);

   305 				}

   306 			}

   307 

   308 		HCR::TRepositoryCompiled* compiledRepos = reinterpret_cast<HCR::TRepositoryCompiled*>(gObserver.GetVariantImgRepos());

   309 		__NK_ASSERT_DEBUG(compiledRepos != NULL);

   310 

   311 		ids[0]->iCat = KHCRUID_TestCategory1;

   312 		ids[0]->iKey = key;    

   313 		

   314 		// Negative tests on HCR::TRepositoryCompiled; aNum will be 0

   315 		r = compiledRepos->GetWordSettings(0, ids, vals, types, errs);

   316 		if(r != KErrNotFound && r != KErrNone && r < KErrNone)

   317 			{

   318 			delete ids[0];

   319 			delete vals[0];

   320 			delete errs[0];

   321 			delete types[0];

   322 			NKern::ThreadLeaveCS();

   323 			HCR_TRACE_RETURN(r);

   324 			}

   325 

   326 		// Negative testing on HCR::TRepositoryFile; try to get words for large value

   327 		if(type > HCR::ETypeLinAddr)

   328 			{

   329 			r = compiledRepos->GetWordSettings(1, ids, vals, types, errs);

   330 			if(r != KErrArgument && r != KErrNotFound && r < KErrNone)

   331 				{

   332 				delete ids[0];

   333 				delete vals[0];

   334 				delete errs[0];

   335 				delete types[0];

   336 				NKern::ThreadLeaveCS();

   337 				HCR_TRACE_RETURN(r);

   338 				}

   339 			}

   340 		

   341 		delete ids[0];

   342 		delete vals[0];

   343 		delete errs[0];

   344 		delete types[0];

   345 		NKern::ThreadLeaveCS();

   346 

   498         

   499     case RHcrTest::ECtrlCheckOverrideRepos102400Content:

   500         {

   501         HCR::TRepository* overrideRepos = gObserver.GetOverrideImgRepos();  // Shadowed SMR/HCR

   502         TInt err = KErrNone;

   503         

   504         if( 0 != overrideRepos )

   505             {

   506             for( TInt index = 0; index < itemsSize; ++index)

   507                 {

   508                 HCR::TSettingId id(items[index].iCategoryUID, items[index].iElementID);

   509                 HCR_TRACE3("--- index:%5d, iCategoryUID:0x%08x, iElementID:0x%08x"

   510                             , index

   511                             , items[index].iCategoryUID

   512                             , items[index].iElementID

   513                             );

   514                 HCR::TSettingRef val(overrideRepos, 0);

   515                 HCR::TSettingType type = (HCR::TSettingType)items[index].iType;

   516     			TInt r = gObserver.FindSetting(id, type, val);

   517     			if( r != KErrNone)

   518     			    {

   519     			        err = KErrNotFound;

   520     			        break;

   521     			    }

   522     			HCR::UValueWord valueWord;

   523                 r = overrideRepos->GetValue(val, valueWord);

   524                 HCR_TRACE1("--- value:0x%08x", valueWord.iUInt32); 

   525                 if( valueWord.iUInt32 != items[index].iValue)

   526                     {

   527                     err = KErrNotFound;

   528     			    break;    

   529                     }

   530                 }

   531             }

   532         return err;

   533         }

   534         

   535     case RHcrTest::ECtrlSwitchFileRepository:

   536 	    {

   537 	    TInt r;

   538 	    TAny* args[2];

   539 	    TEST_MEMGET(a1, args, sizeof(args));

   540 	    const TText* fileRepName = (TText*) args[0];

   541 	    

   542 	    r = gObserver.SwitchRepository(fileRepName, HCR::HCRInternal::ECoreRepos);

   543 	    if (r != KErrNone)

   544 	        {

   545 	        HCR_TRACE_RETURN(r);

   546 	        }

   547 	    else

   548 	        return r;

   549 	    }

   550 	    

   551 	case RHcrTest::ECtrlCompiledFindSettingsInCategory:

   552 	    {

   553 	    TInt r = 0;

   554 	    //Do test for HCR::TRepositoryCompiled

   555 	    TAny* args[3];

   556 	    

   557 

   558 	    //It's a pre-condition to enter critical section before

   559 	    //kernel memory allocation

   560 	    NKern::ThreadEnterCS();

   561 	    TInt32* pFirst = new TInt32;

   562 	    TInt32* pLast = new TInt32;

   563 	    //We've done with allocation, exit CS

   564 	    NKern::ThreadLeaveCS();

   565 	    

   566 	    if(!pFirst || !pLast)

   567 	        { 

   568 	        HCR_TRACE_RETURN(KErrNoMemory);

   569 	        }

   570 	    

   571 	    TEST_MEMGET(a1, args, sizeof(args));

   572 	    HCR::TCategoryUid catUid = (HCR::TCategoryUid)args[0];

   573 	    

   574 	    

   575 	    HCR::TRepositoryCompiled* compiledRepos = 

   576 	    reinterpret_cast<HCR::TRepositoryCompiled*>(gObserver.GetVariantImgRepos());

   577 	    if (compiledRepos == 0) 

   578 	        { 

   579 	        HCR_TRACE_RETURN(KErrGeneral);

   580 	        }

   581 	   

   582 	    //This function return the result of operation r and first element and 

   583 	    //last element in the category written back to the user side test code 

   584 	    //variable referenced by pFirst and pLast pointers

   585 	    r = compiledRepos->FindNumSettingsInCategory(catUid, 

   586 	            *pFirst, *pLast);

   587 	    

   588 	    TEST_MEMPUT(args[1], pFirst, sizeof(TInt32));

   589 	    TEST_MEMPUT(args[2], pLast, sizeof(TInt32));

   590 	    

   591 	    if(r < 0)

   592 	        {HCR_TRACE_RETURN(r);}

   593 	    else

   594 	        return r;

   595 	    }

   596         

   597 	case RHcrTest::ECtrlFileFindSettingsInCategory:

   598 	    {

   599 	    TInt r;

   600 	    TAny* args[3];

   601 	    TEST_MEMGET(a1, args, sizeof(args));

   602 	    HCR::TCategoryUid catUid = (HCR::TCategoryUid)args[0];

   603 

   604 	    //It's a pre-condition to enter critical section before

   605 	    //kernel memory allocation

   606 	    NKern::ThreadEnterCS();

   607 	    TInt32* pFirst = new TInt32;

   608 	    TInt32* pLast = new TInt32;

   609 	    //We've done with allocation, exit CS

   610 	    NKern::ThreadLeaveCS();

   611 

   612 	    if(!pFirst || !pLast)

   613 	        { 

   614 	        HCR_TRACE_RETURN(KErrNoMemory);

   615 	        }

   616 

   617 

   618 	    // Do test for HCR::TRepositoryFile

   619 	    HCR::TRepository* repos = gObserver.GetCoreImgRepos();

   620 	    __NK_ASSERT_DEBUG(repos != NULL);

   621 

   622 	    //This function return the result of operation r and first element and 

   623 	    //last element in the category written back to the user side test code 

   624 	    //variable referenced by pFirst and pLast pointers

   625 	    r = repos->FindNumSettingsInCategory(catUid, 

   626 	            *pFirst, *pLast);

   627 

   628 	    TEST_MEMPUT(args[1], pFirst, sizeof(TInt32));

   629 	    TEST_MEMPUT(args[2], pLast, sizeof(TInt32));

   630 

   631 	    if(r < 0)

   632 	        {HCR_TRACE_RETURN(r);}

   633 	    else

   634 	        return r;

   635 	    }

   636 	    

   637 	           

   666 

   667 	new(&gTestHcrInt) HCR::HCRInternal(varPtr);