214 return KErrNone; |
230 return KErrNone; |
215 } |
231 } |
216 |
232 |
217 case RHcrTest::ECtrlGetWordSetting: |
233 case RHcrTest::ECtrlGetWordSetting: |
218 { |
234 { |
|
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 |
219 return KErrNone; |
347 return KErrNone; |
220 } |
348 } |
221 |
349 |
222 case RHcrTest::ECtrlGetLargeSetting: |
350 case RHcrTest::ECtrlGetLargeSetting: |
223 { |
351 { |
301 HCR_TRACE_RETURN(KErrGeneral); |
429 HCR_TRACE_RETURN(KErrGeneral); |
302 |
430 |
303 return err; |
431 return err; |
304 } |
432 } |
305 |
433 |
306 case RHcrTest::ECtrlFreePhyscialRam: |
434 case RHcrTest::ECtrlNegativeTestsLargeValues: |
|
435 { |
|
436 //Test that HCR::TRepositoryCompiled::GetLargeValue & HCR::TRepositoryFile::GetLargeValue return KErrArgument |
|
437 TAny* args[1]; |
|
438 TEST_MEMGET(a1, args, sizeof(args)); |
|
439 // Retrieve structures from client |
|
440 TInt expectedError = (TUint) args[0]; |
|
441 |
|
442 const TText * fileInSysBinName = (const TText *)"filerepos.dat"; |
|
443 TInt err = gObserver.SwitchRepository(fileInSysBinName, HCR::HCRInternal::ECoreRepos); |
|
444 if (err != KErrNone) |
|
445 HCR_TRACE_RETURN(err); |
|
446 |
|
447 // Do test for HCR::TRepositoryFile |
|
448 HCR::TRepository* repos = gObserver.GetCoreImgRepos();; |
|
449 __NK_ASSERT_DEBUG(repos != NULL); |
|
450 |
|
451 HCR::UValueLarge value; |
|
452 HCR::TSettingRef ref(0,0); |
|
453 HCR::TSettingId id(1,1); //word setting value in repository |
|
454 err = repos->FindSetting(id, ref); |
|
455 if(err == KErrNone) |
|
456 { |
|
457 err = repos->GetLargeValue(ref, value); |
|
458 if(err != expectedError) |
|
459 { |
|
460 HCR_TRACE_RETURN(err); |
|
461 } |
|
462 } |
|
463 |
|
464 //Do test for HCR::TRepositoryCompiled |
|
465 HCR::TRepositoryCompiled* compiledRepos = reinterpret_cast<HCR::TRepositoryCompiled*>(gObserver.GetVariantImgRepos()); |
|
466 if (compiledRepos == 0) |
|
467 { |
|
468 HCR_TRACE_RETURN(KErrGeneral); |
|
469 } |
|
470 |
|
471 id = HCR::TSettingId(KHCRUID_TestCategory1,1); |
|
472 err = compiledRepos->FindSetting(id, ref); |
|
473 if(err == KErrNone) |
|
474 { |
|
475 err = compiledRepos->GetLargeValue(ref, value); |
|
476 if(err != expectedError) |
|
477 { |
|
478 HCR_TRACE_RETURN(err); |
|
479 } |
|
480 } |
|
481 |
|
482 return KErrNone; |
|
483 } |
|
484 |
|
485 |
|
486 case RHcrTest::ECtrlCheckOverrideReposIntegrity: |
307 { |
487 { |
308 return KErrNone; |
488 HCR::TRepository* overrideRepos = gObserver.GetOverrideImgRepos(); // Shadowed SMR/HCR |
|
489 TInt err = KErrNone; |
|
490 |
|
491 if( 0 != overrideRepos ) |
|
492 { |
|
493 err = overrideRepos->CheckIntegrity(); |
|
494 |
|
495 } |
|
496 return err; |
309 } |
497 } |
|
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 |
310 |
638 |
311 default: |
639 default: |
312 break; |
640 break; |
313 } |
641 } |
314 |
642 |