/*
* Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "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: 
*
*/

/**
 @file
 @test
 @internalComponent Internal Symbian test code
*/

#include "FNTSTORE.H"
#include "t_fontsessioncache.h"
#include "T_IsolatedFontStore.h"

_LIT(KWorkerProcess,"tfontsessioncacheproc");
_LIT(KSharedChunk,"TestSharedChunk_T_FontSessionCache");

const TInt KNumOfProc = 4;
const TInt KRunningTime = 1000 * 1000 * 5;

//Make sure font is large enough that font and session caches are used sufficiently. 
const TInt KFontHeight = 250;   

// This class is a data mirror to CBitmapFont in order to check its private 
// member iOpenFont. It is only used by TestOpenFontForQtL().
class CBitmapFontDummy:public CFont
    {
public:
    TFontSpec iFontSpecInTwips;
    TAlgStyle iAlgStyle;        
    RHeap* iHeap;
    TInt iFontBitmapOffset;
    COpenFont* iOpenFont; 
    TUint32 iReserved;
    TUint32 iUniqueFontId;     
    };

class CTFontSessionCache : public CTGraphicsBase
    {
public:
    CTFontSessionCache(CTestStep* aStep);
    ~CTFontSessionCache();
    TInt Base();

protected:
// From CTGraphicsStep
    virtual void RunTestCaseL(TInt aCurTestCase);
    virtual void ConstructL();
private:
    void TestOpenFontForQtL();
    void RunMultiWorkerProcessL();
    
    void FlushCaches();
    
private:
    CTIsolatedFontStore *iIFontStore;
    RHeap   *iSharedHeap;
    RChunk  iChunk;
    CFont *iFont;
    };

CTFontSessionCache::CTFontSessionCache(CTestStep* aStep)
 :  CTGraphicsBase(aStep)
    {

    }

CTFontSessionCache::~CTFontSessionCache()
    {
    iIFontStore->iFs->ReleaseFont(iFont);
    delete iIFontStore;
    iChunk.Close(); 
    }

inline TInt CTFontSessionCache::Base() 
    {
    return reinterpret_cast<TInt>(iChunk.Base());
    }

void CTFontSessionCache::ConstructL()
    {
    User::LeaveIfError(iChunk.CreateGlobal(KNullDesC,0x10000,0x10000));
    iSharedHeap = UserHeap::ChunkHeap(iChunk,0x10000,0x1000,0x10000,0,EFalse,0);
    if(iSharedHeap == NULL)
        {
        RDebug::Print(_L("iSharedHeap = NULL"));
        User::Leave(KErrNoMemory);
        }
    iIFontStore = CTIsolatedFontStore::NewL(iSharedHeap);
    iIFontStore->LoadRasterizersL();
    iIFontStore->iFs->LoadFontsAtStartupL();
    
    _LIT(KTypefaceName, "DejaVu Sans Condensed");
    TFontSpec spec(KTypefaceName, KFontHeight);   
    
    TInt ret = iIFontStore->iFs->GetNearestFontToDesignHeightInPixels(iFont,spec);
    TEST(ret == KErrNone);
 
    }

void CTFontSessionCache::FlushCaches()
    {
    TText ch;
    TOpenFontGlyphData *glyphData = NULL;
    for (TInt sHandle = 0; sHandle < KNumOfProc; sHandle++)
        {
        for (ch = 'A'; ch <= 'z'; ch++)
            {
            static_cast<CBitmapFont*> (iFont)->Rasterize(sHandle, ch, glyphData);
            }
        }
    }

/**
    @SYMTestCaseID
    TI18N-FNTSTORE-UT--4003

    @SYMTestCaseDesc
    Qt needs the last bit of iOpenFont to be set 1 as a workaround to maintain
    its compatibility across difference Symbian OS versions.

    @SYMTestActions
    1. Get a CBitmapFont in the constructor
    2. Check the LSB of its iOpenFont by using CBitmapFontDummy
        
    @SYMTestExpectedResults
    Test should pass
*/

void CTFontSessionCache::TestOpenFontForQtL()
    {    
    TEST(reinterpret_cast<TInt>(reinterpret_cast<CBitmapFontDummy*>(iFont)->iOpenFont) & 1);
    }

/**
    @SYMTestCaseID
    TI18N-FNTSTORE-CIT-4002

    @SYMTestCaseDesc
    This case is to test the safty of actions over the shared heap.

    @SYMTestActions
    1. Shared heap is initialised in the constructor
    2. Run rasterizing function to Flush the font caches(glyph tree and session cache).
    3. Launch KNumOfProc worker processes running with random latency at beginning, which
       is to seach the cache from different processes. The globle chunk and font handles are
       passed via process environment variables.
    4. Each one lasts about 1 sec. Within duration of 5 sec, if one terminates, re-launch it.   
        
    @SYMTestExpectedResults
    Test should pass without any Panic.
*/
void CTFontSessionCache::RunMultiWorkerProcessL()
    {
    RProcess ProcArray[KNumOfProc];
    TRequestStatus *completeStatus[KNumOfProc];

    FlushCaches();
    
    for (TInt i = 0; i < KNumOfProc; i++)
        {                    
        RDebug::Print(_L(">>> Launching %d..."),i);
        TInt err;
        err = ProcArray[i].Create(KWorkerProcess, KNullDesC);
        User::LeaveIfError(err);

        TInt FontOffset = reinterpret_cast<TInt>(iFont) - Base();
        ProcArray[i].SetParameter(1,iChunk);        
        ProcArray[i].SetParameter(2,FontOffset);
        ProcArray[i].SetParameter(3,i);
        
        completeStatus[i] = new(ELeave) TRequestStatus; 
        CleanupStack::PushL(completeStatus[i]);
        *completeStatus[i] = KRequestPending;
        
        ProcArray[i].Logon(*completeStatus[i]);
        ProcArray[i].Resume(); //start the process
        }
      
    RTimer timer;
    timer.CreateLocal();
    TRequestStatus timerStatus = KRequestPending;
    TTimeIntervalMicroSeconds32 timeout(KRunningTime);
    timer.After(timerStatus, timeout);
    
    do
        {     
        User::WaitForNRequest(completeStatus, KNumOfProc);
        TInt i = 0;
        for(;i < KNumOfProc;i++ )
            {
                if (*completeStatus[i] != KRequestPending)
                {
                break;
                }
            }

        TExitType exit = ProcArray[i].ExitType();
        TEST(exit == EExitKill);
        TInt reason = ProcArray[i].ExitReason();
        TEST (reason == 0);

        RDebug::Print(_L("<<< Close %d..."), i);
        ProcArray[i].Close();

        RDebug::Print(_L(">>> Launching %d..."), i);
        TInt err;
        err = ProcArray[i].Create(KWorkerProcess, KNullDesC);
        User::LeaveIfError(err);
        
        TInt FontOffset = reinterpret_cast<TInt>(iFont) - Base();
        ProcArray[i].SetParameter(1,iChunk);        
        ProcArray[i].SetParameter(2,FontOffset);
        ProcArray[i].SetParameter(3,i);
        
        //run process 1
        *completeStatus[i] = KRequestPending;
        ProcArray[i].Logon(*completeStatus[i]);
        ProcArray[i].Resume(); //start the process
        }
    while (timerStatus == KRequestPending);
    
    for (TInt i = 0; i < KNumOfProc; i++)
        {
        if(*completeStatus[i] == KRequestPending)
            {
            User::WaitForRequest(*completeStatus[i]);
            }       
        RDebug::Print(_L("<<< Tear down Close %d..."),i);
        ProcArray[i].Close(); //tear down
        }        
    CleanupStack::PopAndDestroy(KNumOfProc);
    }

void CTFontSessionCache::RunTestCaseL( TInt aCurTestCase )
    {
    ((CTFontSessionCacheStep*) iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

    switch (aCurTestCase)
        {
        case 1:
            ((CTFontSessionCacheStep*) iStep)->SetTestStepID(_L("TI18N-FNTSTORE-UT--4003"));
            INFO_PRINTF1(_L("Test CBitmapFont::iOpenFont last bit for Qt\n"));
            TestOpenFontForQtL();
            break;

        case 2:
            ((CTFontSessionCacheStep*) iStep)->SetTestStepID(_L("TI18N-FNTSTORE-CIT-4002"));
            INFO_PRINTF1(_L("Test GetCharacterData() in muti-process client\n"));
            RunMultiWorkerProcessL();
            break;
            
        case 3:
            ((CTFontSessionCacheStep*) iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
            ((CTFontSessionCacheStep*) iStep)->CloseTMSGraphicsStep();
            TestComplete();
            break;
        }
    ((CTFontSessionCacheStep*)iStep)->RecordTestResultL();
    }

// --------------
__CONSTRUCT_STEP__(FontSessionCache)