// 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;
   	
	}