// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // Prototype HCR test driver library

 //

 // -- INCLUDES ----------------------------------------------------------------

 #include "hcr_uids.h"

 #include "hcr_debug.h"

 #include <kernel/kern_priv.h>

 #include <platform.h>

 #include <u32hal.h>

 #include "d_hcrut.h"

 #include "hcr_hai.h"

 #include "hcr_pil.h"

 #include <drivers/hcr.h>

 #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:

 	virtual TInt Install();

 	virtual void GetCaps(TDes8& aDes) const;

 	virtual TInt Create(DLogicalChannelBase*& aChannel);

 	};

 class DHcrTestChannel : public DLogicalChannelBase

 	{

 public:

 	DHcrTestChannel();

 	virtual ~DHcrTestChannel();

 	//	Inherited from DObject

 	virtual TInt RequestUserHandle(DThread* aThread, TOwnerType aType);

 	// Inherited from DLogicalChannelBase

 	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

 	virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2);

 public:

 	static void TestTrace(DHcrTestChannel* aSelf);

 private:

 	DThread* iClient;

 	};

 namespace HCR {

 class HCRInternalTestObserver 

 	{

 public:

 	HCRInternalTestObserver() : iHcrInt(0) { return; } ;

 	HCRInternalTestObserver(HCR::HCRInternal* aSubject) :

 		iHcrInt(aSubject) { return; } ;

 	~HCRInternalTestObserver() { return; } ; 

 	TInt PrintAttirbutes(); 

 	TInt PrintState();

 	HCR::TRepository* GetVariantImgRepos();

 	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:

 	HCR::HCRInternal* iHcrInt;

 	};

 }

 TInt Testfunc1(TSuperPage* aSuperPagePtr);

 TInt HCR::HCRInternalTestObserver::PrintAttirbutes() 

 	{

 	HCR_TRACE1("HCRInternalTestObserver initialised, iVariant=0x%0x\n", iHcrInt->iVariant);

 	return KErrNone;

 	}

 TInt HCR::HCRInternalTestObserver::PrintState() 

 	{

 	HCR_TRACE2("iVariant     =0x%08X, iVariantStore =0x%08X, \n", iHcrInt->iVariant, iHcrInt->iVariantStore);

 	HCR_TRACE2("iCoreImgStore=0x%08X, iOverrideStore=0x%08X, \n", iHcrInt->iCoreImgStore, iHcrInt->iOverrideStore);

 	return KErrNone;

 	}	

 HCR::TRepository* HCR::HCRInternalTestObserver::GetVariantImgRepos()

 	{

 	return iHcrInt->iVariantStore;

 	}

 HCR::TRepository* HCR::HCRInternalTestObserver::GetCoreImgRepos()

 	{

 	return iHcrInt->iCoreImgStore;

 	}

 HCR::TRepository* HCR::HCRInternalTestObserver::GetOverrideImgRepos()

 	{

 	return iHcrInt->iOverrideStore;

 	}

 TInt HCR::HCRInternalTestObserver::SwitchRepository(const TText * aFileName, const HCR::HCRInternal::TReposId aId)

     {

     NKern::ThreadEnterCS();

     TInt retVal = iHcrInt->SwitchRepository(aFileName, aId);

     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 -----------------------------------------------------------------

 //

 static HCR::HCRInternal gTestHcrInt;

 static HCR::HCRInternalTestObserver gObserver;

 // -- METHODS -----------------------------------------------------------------

 //

 // DHcrTestFactory

 //

 TInt DHcrTestFactory::Install()

 	{

     HCR_FUNC("DHcrTestFactory::Install");

 	return SetName(&RHcrTest::Name());

 	}

 void DHcrTestFactory::GetCaps(TDes8& aDes) const

 	{

     HCR_FUNC("DHcrTestFactory::GetCaps");

   	Kern::InfoCopy(aDes,0,0);

 	}

 TInt DHcrTestFactory::Create(DLogicalChannelBase*& aChannel)

 	{

     HCR_FUNC("DHcrTestFactory::Create");

    	aChannel=new DHcrTestChannel();

 	if(!aChannel)

 		return KErrNoMemory;

 	return KErrNone;

 	}

 // -- METHODS -----------------------------------------------------------------

 //

 // DHcrTestChannel

 //

 DHcrTestChannel::DHcrTestChannel()

 	{

     HCR_FUNC("DHcrTestChannel");

    	}

 DHcrTestChannel::~DHcrTestChannel()

 	{

     HCR_FUNC("~DHcrTestChannel");

 	}

 TInt DHcrTestChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

 	{

     HCR_FUNC("DHcrTestChannel::DoCreate");

     iClient = &Kern::CurrentThread();

 	return KErrNone;

 	}

 TInt DHcrTestChannel::RequestUserHandle(DThread* aThread, TOwnerType aType)

 	{

     HCR_FUNC("DHcrTestChannel::RequestUserHandle");

 	if (aType!=EOwnerThread || aThread!=iClient)

 		return KErrAccessDenied;

 	return KErrNone;

 	}

 TInt DHcrTestChannel::Request(TInt aReqNo, TAny* a1, TAny* /*a2*/ )

 	{

     HCR_FUNC("DHcrTestChannel::Request");

 	switch(aReqNo)

 		{

 	case RHcrTest::ECtrlSanityTestWordSettings:

 		{

  		return KErrNone;

 		}

 	case RHcrTest::ECtrlSanityTestLargeSettings:

 		{

 		return KErrNone;

 		}

 	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<HCR::TRepositoryCompiled*>(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;

 		}

 	case RHcrTest::ECtrlGetLargeSetting:

 		{

 		return KErrNone;

 		}

 	case RHcrTest::ECtrlGetManyWordSettings:

 		{

 		return KErrNone;

 		}

 	case RHcrTest::ECtrlGetManyLargeSettings:

 		{

 		return KErrNone;

 		}

 	case RHcrTest::ECtrlSwitchRepository:

 		{

 		TInt err = KErrNone;

         // Clear and reset iCoreImgStore

 	    HCR_TRACE1("--- value of iCoreImgStore:0x%08x before clear", gObserver.GetCoreImgRepos());

 	    err = gObserver.SwitchRepository(NULL, HCR::HCRInternal::ECoreRepos);

     	HCR_TRACE1("--- value of iCoreImgStore:0x%08x after clear",  gObserver.GetCoreImgRepos());

     	if( err != KErrNone )

     		{

     		return err;

     		}

     	// Clear and reset iOverrideStore	

         HCR_TRACE1("--- value of iOverrideStore:0x%08x before clear", gObserver.GetOverrideImgRepos());

 	    err = gObserver.SwitchRepository(NULL, HCR::HCRInternal::EOverrideRepos);

     	HCR_TRACE1("--- value of iOverrideStore:0x%08x after clear",  gObserver.GetOverrideImgRepos());

     	if( err != KErrNone )

     		{

     		return err;

     		}

 	    // Switch iCoreImgStore to a repositore store located in \sys\bin directory

 		const TText * fileInSysBinName = (const TText *)"d_hcrsim_own.ldd";

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

 		if (err != KErrNone)

              HCR_TRACE_RETURN(err);

         // Switch iOverrideStore to a repositore store located in \sys\Data directory

         const TText * fileInSysDataName = (const TText *)"EMPTY.DAT";

         err = gObserver.SwitchRepository(fileInSysDataName, HCR::HCRInternal::EOverrideRepos);

 		if (err != KErrNone)

              HCR_TRACE_RETURN(err);

         // Try to switch iCoreImgStore to a not existing one and check the SwitchRepository() 

         // keeps its original value.

         HCR::TRepository* oldRepos = gObserver.GetCoreImgRepos();

         HCR_TRACE1("--- value of iCoreImgStore:0x%08x before try to switch to a not exist", oldRepos);

         const TText * wrongFileName = (const TText *)"hcr.ldl";

 		err = gObserver.SwitchRepository(wrongFileName, HCR::HCRInternal::ECoreRepos);

 		if ( err != KErrNotFound)

              HCR_TRACE_RETURN(err);

         err = KErrNone;

         HCR::TRepository* newRepos = gObserver.GetCoreImgRepos();     

         HCR_TRACE1("--- value of iCoreImgStore:0x%08x after try to switch to a not exist", newRepos);             

         if ( oldRepos != newRepos )

             HCR_TRACE_RETURN(KErrGeneral);

         // Switch iOverrideStore to a new, existing repository, different the current and check the 

         // iOverrideStore value changed.

         oldRepos = gObserver.GetOverrideImgRepos();

         HCR_TRACE1("--- value of iOverrideStore:0x%08x before try to switch to existing one", oldRepos);

 		err = gObserver.SwitchRepository(fileInSysBinName, HCR::HCRInternal::EOverrideRepos);

 		if ( err != KErrNone)

              HCR_TRACE_RETURN(err);

         newRepos = gObserver.GetOverrideImgRepos();     

         HCR_TRACE1("--- value of iOverrideStore:0x%08x after try to switch to existing on", newRepos);             

         if ( oldRepos == newRepos )

             HCR_TRACE_RETURN(KErrGeneral);            

 		return err;

 		}

 	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<HCR::TRepositoryCompiled*>(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:

         {

         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<HCR::TRepositoryCompiled*>(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;

 		}

 	return KErrNotSupported;

 	}

 // -- GLOBALS -----------------------------------------------------------------

 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);

 	err = gTestHcrInt.Initialise();

 	if (err != KErrNone)

     	return 0;

 	new(&gObserver) HCR::HCRInternalTestObserver(&gTestHcrInt);

 	// ===== Above would be moved to DoRequest for test caes....

    	return new DHcrTestFactory;

 	}