// Copyright (c) 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:
//

#include <gdi.h>
#include <fbs.h> 
#include <e32test.h>
#include <e32property.h>
#include <graphics/openfontconstants.h>
#include <graphics/openfontrasterizer.h>
#include <graphics/gdi/gdiplatapi.h>
#include "fbsmessage.h"
#include "tfonttableandglyph.h"

//global variable
_LIT16(KTestFontFile, "C:\\DejaVuSans.ttf");
_LIT16(KTestFontFaceName, "DejaVu Sans");

_LIT16(KTestFontFile2, "C:\\DejaVuSerif.ttf");
_LIT16(KTestFontFaceName2, "DejaVu Serif");

static void LoadOpenFontLibraries(CFontStore* aFontStore);

LOCAL_C const TInt KFontHeight = 12;
LOCAL_C const TInt KInvalidGlyphId = 0xffff;

CTFontAndGlyph::CTFontAndGlyph(CTestStep* aStep) :
    CTGraphicsBase(aStep),
    iBmp(NULL),
    iBmp2(NULL),
    iDevice(NULL),
    iDevice2(NULL),
    iFont(NULL),
    iFont2(NULL),
    iFontStore(NULL),
    iFontSpec(KTestFontFaceName, KFontHeight),
    iFontSpec2(KTestFontFaceName2, KFontHeight)
    {
        // a null constructor
    }

CTFontAndGlyph::~CTFontAndGlyph()
    {
    CleanEnv();
    }

void CTFontAndGlyph::RunTestCaseL(TInt aCurTestCase)
    {
    ((CTFontAndGlyphStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
    
    switch(aCurTestCase)
        {
    case 1:
        ((CTFontAndGlyphStep*)iStep)->SetTestStepID(_L("TI18N-GDI-CIT-4079"));
        INFO_PRINTF1(_L("GetHintedGlyphById"));
        GetHintedGlyphById(); 
        break;
        
    case 2:
        ((CTFontAndGlyphStep*)iStep)->SetTestStepID(_L("TI18N-GDI-CIT-4080"));
        INFO_PRINTF1(_L("GetUnHintedGlyphById"));
        GetUnHintedGlyphById();
        break;
               
    case 3:
        ((CTFontAndGlyphStep*)iStep)->SetTestStepID(_L("TI18N-GDI-CIT-4081"));
        INFO_PRINTF1(_L("GetHintedGlyphByWrongId"));
        GetHintedGlyphByWrongId();
        break;   
        
    case 4:
        ((CTFontAndGlyphStep*)iStep)->SetTestStepID(_L("TI18N-GDI-CIT-4082"));
        INFO_PRINTF1(_L("GetGlyphWithNoMem"));
        GetGlyphWithNoMem();
        break; 
        
    case 5:
        ((CTFontAndGlyphStep*)iStep)->SetTestStepID(_L("TI18N-GDI-CIT-4083"));
        INFO_PRINTF1(_L("GetFontTable"));
        GetFontTable();
        break;         
        
        
    case 6:
        ((CTFontAndGlyphStep*)iStep)->SetTestStepID(_L("TI18N-GDI-CIT-4084"));
        INFO_PRINTF1(_L("GetFontTableByWrongTag"));
        GetFontTableByWrongTag();
        break;        

    case 7:
        ((CTFontAndGlyphStep*)iStep)->SetTestStepID(_L("TI18N-GDI-CIT-4085"));
        INFO_PRINTF1(_L("GetFontTableWithNoMem"));
        GetFontTableWithNoMem();
        break;    
        
    case 8:
        ((CTFontAndGlyphStep*)iStep)->SetTestStepID(_L("TI18N-GDI-CIT-4089"));
        INFO_PRINTF1(_L("GlyphOutlineIteratorPanics"));
        GlyphOutlineIteratorPanics();
        break;   
        
    case 9:
        ((CTFontAndGlyphStep*)iStep)->SetTestStepID(_L("TI18N-GDI-CIT-4090"));
        INFO_PRINTF1(_L("WDPAndSMPSafeTest"));
        SMPAndWDPSafeTest();
        break;
        
    case 10:
        ((CTFontAndGlyphStep*)iStep)->SetTestStepID(_L("TI18N-GDI-CIT-4087"));
        INFO_PRINTF1(_L("TestFbsFontHandleIsZeroForFont"));
        TestFbsFontHandleIsZeroForFont();
        break;  

    case 11:
        ((CTFontAndGlyphStep*)iStep)->SetTestStepID(_L("TI18N-GDI-CIT-4088"));
        INFO_PRINTF1(_L("TestFbsFontHandleIsZeroForGlyph"));
        TestFbsFontHandleIsZeroForGlyph();
        break;   
        
    case 12:
        ((CTFontAndGlyphStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
        ((CTFontAndGlyphStep*)iStep)->CloseTMSGraphicsStep();
        TestComplete();
        break;
    default:
        INFO_PRINTF1(_L("Invalid test case id found."));
        }    
        ((CTFontAndGlyphStep*)iStep)->RecordTestResultL();
    }


/**
    @SYMTestCaseID    TI18N-GDI-CIT-4083
    @SYMTestCaseDesc    Get font table. 
    @SYMTestActions    Get font table using the new RFontTable class and test
    the return value.
    @SYMTestExpectedResults  Open() returns KErrNone. TableContent returns the
    table content. 
*/
void CTFontAndGlyph::GetFontTable()
    {
    __UHEAP_MARK;
    RFontTable fontTable;
    TInt err = fontTable.Open(*iFont, 0x68656164);  
    TEST(err == KErrNone);
    TUint32* tablePtr = (TUint32*)fontTable.TableContent();     
    TEST(tablePtr != NULL);
    TEST(tablePtr[3] == 0xF53C0F5F);   //magic number is correct
    RFontTable fontTableInCache;
    err = fontTableInCache.Open(*iFont, 0x68656164);  
    TEST(err == KErrNone);
    TUint32* tablePtr2 = (TUint32*)fontTableInCache.TableContent();  
    TEST(tablePtr2[3] == 0xF53C0F5F);
    TEST(tablePtr == tablePtr2);
    
    RFontTable fontTable2;
    err = fontTable2.Open(*iFont2, 0x68656164);  
    TEST(err == KErrNone);
    tablePtr = (TUint32*)fontTable2.TableContent();     
    TEST(tablePtr != NULL);
    TEST(tablePtr[3] == 0xF53C0F5F);   //magic number is correct
    RFontTable fontTableInCache2;
    err = fontTableInCache2.Open(*iFont2, 0x68656164);  
    TEST(err == KErrNone);
    tablePtr2 = (TUint32*)fontTableInCache2.TableContent();  
    TEST(tablePtr2[3] == 0xF53C0F5F);
    TEST(tablePtr == tablePtr2);
    
    fontTableInCache.Close();
    fontTable.Close();
    fontTableInCache2.Close();
    fontTable2.Close();
    __UHEAP_MARKEND;
    }


/**
    @SYMTestCaseID    TI18N-GDI-CIT-4084
    @SYMTestCaseDesc    Get font table, providing an invalid tag. 
    @SYMTestActions    Get font table, providing an invalid tag (0). 
    Test the return value.
    @SYMTestExpectedResults    Open() returns KErrNotFound.
*/
void CTFontAndGlyph::GetFontTableByWrongTag()
    {
    __UHEAP_MARK;
    RFontTable fontTableForWrongID;
    TInt err = fontTableForWrongID.Open(*iFont, 0);  
    fontTableForWrongID.Close(); 
    TEST(KErrNotFound == err); 
    __UHEAP_MARKEND;
    }


/**
    @SYMTestCaseID    TI18N-GDI-CIT-4085
    @SYMTestCaseDesc    Get font table, when system is OOM. 
    @SYMTestActions    Get font table, simulate OOM conditions using debug macros,
     and test return value.
    @SYMTestExpectedResults    Open() returns KErrNoMemory. TableContent() and 
    TableLength() return NULL/0.
*/
void CTFontAndGlyph::GetFontTableWithNoMem()
    {
#ifdef _DEBUG 
    __UHEAP_MARK;
    RFontTable aFontTableForMem;
    RFbsSession *fbsSession = RFbsSession::GetSession();
    fbsSession->SendCommand(EFbsMessSetHeapFail, RFbsSession::EHeapFailTypeHeapMemory, 1);
    TInt err = aFontTableForMem.Open(*iFont, 0x68656164); /* 'head' in ascii (hex) */
    TEST(KErrNoMemory == err);
    TEST(0 == aFontTableForMem.TableLength());
    TEST(0 == aFontTableForMem.TableContent());
    aFontTableForMem.Close();
    fbsSession->SendCommand(EFbsMessSetHeapReset, RFbsSession::EHeapFailTypeHeapMemory);
    __UHEAP_MARKEND;
#else
    INFO_PRINTF1(_L("Skipping test GetFontTableWithNoMem in release mode")); 
#endif
    }


/**
    @SYMTestCaseID    TI18N-GDI-CIT-4082
    @SYMTestCaseDesc    Get glyph outline when system is out of memory.
    @SYMTestActions    Get  glyph outline. Simulate OOM faliures using debug
    macros to check if the program logic is correct.
    @SYMTestExpectedResults    Open() always returns KErrNoMemory.
*/
void CTFontAndGlyph::GetGlyphWithNoMem()
    {
#ifdef _DEBUG 
    __UHEAP_MARK;
    RFbsSession *fbsSession = RFbsSession::GetSession();
    
    TUint glyphIndex[] = {4, 4, KInvalidGlyphId};  
    __UHEAP_FAILNEXT(1);
    RGlyphOutlineIterator it1;    
    TInt err = it1.Open(*iFont, glyphIndex, sizeof(glyphIndex)/sizeof(glyphIndex[0]), ETrue);
    TEST(err == KErrNoMemory);
    it1.Close(); 
    
    __UHEAP_FAILNEXT(2);
    RGlyphOutlineIterator it2;
    err = it2.Open(*iFont, glyphIndex, sizeof(glyphIndex)/sizeof(glyphIndex[0]));
    TEST(err == KErrNoMemory);
    TEST(KErrNotFound == it2.Next());
    it2.Close(); 
    
    __UHEAP_FAILNEXT(3);
    RGlyphOutlineIterator it3;
    err = it3.Open(*iFont, glyphIndex, sizeof(glyphIndex)/sizeof(glyphIndex[0]), ETrue);
    TEST(err == KErrNoMemory);
    TEST(KErrNotFound == it2.Next());
    it3.Close(); 
    
    RGlyphOutlineIterator it4;  
    fbsSession = RFbsSession::GetSession();
    fbsSession->SendCommand(EFbsMessSetHeapFail, RFbsSession::EHeapFailTypeServerMemory, 1);
    err = it4.Open(*iFont, glyphIndex, sizeof(glyphIndex)/sizeof(glyphIndex[0])); 
    TEST(KErrNoMemory == err);
    TEST(KErrNotFound == it2.Next());
    fbsSession->SendCommand(EFbsMessSetHeapReset, RFbsSession::EHeapFailTypeServerMemory);
    it4.Close();
    
    __UHEAP_FAILNEXT(4);
    RGlyphOutlineIterator it5;
    err = it5.Open(*iFont, glyphIndex, sizeof(glyphIndex)/sizeof(glyphIndex[0]));
    TEST(err == KErrNoMemory);
    TEST(KErrNotFound == it2.Next());
    it5.Close();
    __UHEAP_MARKEND;
#else
    INFO_PRINTF1(_L("Skipping test GetGlyphWithNoMem in release mode"));
#endif
    }


/**
    @SYMTestCaseID    TI18N-GDI-CIT-4079
    @SYMTestCaseDesc    Get hinted glyph outline
    @SYMTestActions    Get hinted glyph outline for glyph 4 and 65536. 
    Pass NULL for the 'aCodes' argument, and 0 for the 'aCount' to test 
    param validation. Check return values in each situation.
    @SYMTestExpectedResults    Open() returns KErrNone. Outline() returns a 
    valid pointer to the string representing the outline. OutlineLength() returns
    the corresponding string length.
*/
void CTFontAndGlyph::GetHintedGlyphById()
    {
    __UHEAP_MARK;
    RGlyphOutlineIterator glyphIterator1;
    TUint glyphIndex[] = {4, 4, KInvalidGlyphId};  //two 4 to ensure the 2nd glyph is in cache.
    TInt err = glyphIterator1.Open(*iFont, glyphIndex, sizeof(glyphIndex)/sizeof(glyphIndex[0]), ETrue);
    TEST(err == KErrNone);  
    TInt len1 = glyphIterator1.OutlineLength();   
    const TUint8* ptr1 = glyphIterator1.Outline();
    TInt end = glyphIterator1.Next();
    const TUint8* ptr2 = glyphIterator1.Outline();
    TInt len2= glyphIterator1.OutlineLength(); 
    TEST(len1 > 0);  
    TEST(ptr1 != NULL);
    TEST(ptr1 == ptr2);  
    TEST(len1 == len2); 
        
    RGlyphOutlineIterator glyphIterator1b;  // for font file 2
    TUint glyphIndex_2[] = {0x41, 0x41, KInvalidGlyphId}; 
    err = glyphIterator1b.Open(*iFont2, glyphIndex_2, 
            sizeof(glyphIndex_2)/sizeof(glyphIndex_2[0]), ETrue);
    TEST(err == KErrNone);  
    len1 = glyphIterator1b.OutlineLength();   
    ptr1 = glyphIterator1b.Outline();
    end = glyphIterator1b.Next();
    ptr2 = glyphIterator1b.Outline();
    len2= glyphIterator1b.OutlineLength(); 
    TEST(len1 > 0);  
    TEST(ptr1 != NULL);
    TEST(ptr1 == ptr2);  
    TEST(len1 == len2); 
    
    end = glyphIterator1.Next();    
    len1 = glyphIterator1.OutlineLength(); 
    ptr1 = glyphIterator1.Outline();
    // for the invalid glyph id, len1<0 indicates an error.
    TEST(NULL == ptr1);
    TEST(len1 < 0);
    end = glyphIterator1.Next();
    TEST(KErrNotFound == end);
    // calling Outline() or OutlineLength() causes panic if Next() 
    // returns KErrNotFound
    glyphIterator1.Close();

    end = glyphIterator1b.Next();    
    len1 = glyphIterator1b.OutlineLength(); 
    ptr1 = glyphIterator1b.Outline();
    // for the invalid glyph id, len1<0 indicates an error.
    TEST(NULL == ptr1);
    TEST(len1 < 0);
    end = glyphIterator1b.Next();
    TEST(KErrNotFound == end);
    // calling Outline() or OutlineLength() causes panic if Next() 
    // returns KErrNotFound
    glyphIterator1b.Close();
    
    RGlyphOutlineIterator glyphIterator3;
    err = glyphIterator3.Open(*iFont, glyphIndex, 0, ETrue);
    TEST(KErrArgument == err);
    TEST(KErrNotFound == glyphIterator3.Next());
    glyphIterator3.Close();  
    
    RGlyphOutlineIterator glyphIterator4;
    err = glyphIterator4.Open(*iFont, NULL, sizeof(glyphIndex)/sizeof(glyphIndex[0]), ETrue);
    TEST(KErrArgument == err);
    TEST(KErrNotFound == glyphIterator4.Next());
    glyphIterator4.Close(); 
    __UHEAP_MARKEND;
    }


/**
    @SYMTestCaseID    TI18N-GDI-CIT-4081
    @SYMTestCaseDesc    Get hinted glyph outline, passing in invalid IDs.
    @SYMTestActions    Get hinted glyph outline, passing in invalid IDs. Check 
    the return values.
    @SYMTestExpectedResults    Open() returns KErrNone. Outline() returns NULL.
    OutlineLength() returns KErrGeneral.
*/
void CTFontAndGlyph::GetHintedGlyphByWrongId()
    {
    __UHEAP_MARK;
    RGlyphOutlineIterator glyphIterator;
    TUint glyphIndex[] = {KInvalidGlyphId, KInvalidGlyphId};  
    TInt err = glyphIterator.Open(*iFont, glyphIndex, sizeof(glyphIndex)/sizeof(glyphIndex[0]), ETrue);
    TEST(err == KErrNone);  
    const TUint8* ptr = glyphIterator.Outline();
    TInt len = glyphIterator.OutlineLength();
    TEST(KErrGeneral == len);
    TEST(ptr == NULL);
    TInt ret = glyphIterator.Next();
    TEST(KErrNone == ret);
    glyphIterator.Close();
    __UHEAP_MARKEND;
    }


/**
    @SYMTestCaseID    TI18N-GDI-CIT-4080
    @SYMTestCaseDesc    Get unhinted glyph outline
    @SYMTestActions    Get unhinted glyph outline for glyph 4 and 5. 
    @SYMTestExpectedResults    Open() returns KErrNone. Outline() and 
    OutlineLength() returns the outline string and corresponding length.
*/
void CTFontAndGlyph::GetUnHintedGlyphById()
    {
    __UHEAP_MARK;
    RGlyphOutlineIterator glyphIterator2;
    TUint glyphIndex[] = {4, 4, 5};  //two '4' to ensure the 2nd is in cache.
    TInt err = glyphIterator2.Open(*iFont, glyphIndex, sizeof(glyphIndex)/sizeof(glyphIndex[0]), EFalse);
    TEST(err == KErrNone);   
    const TUint8* ptr1 = glyphIterator2.Outline();
    TInt len1 = glyphIterator2.OutlineLength();     
    err = glyphIterator2.Next();
    TEST(err == KErrNone);
    const TUint8* ptr2 = glyphIterator2.Outline();
    TInt len2= glyphIterator2.OutlineLength(); 
    err = glyphIterator2.Next();
    TEST(err == KErrNone);
    TEST(len1 > 0);  
    TEST(ptr1 == ptr2); 
    TEST(ptr1 != NULL);
    TEST(len1 == len2);      
    
    RGlyphOutlineIterator glyphIterator2b;  // for the 2nd font file
    TUint glyphIndex2[] = {0x41, 0x41, 0x42}; 
    err = glyphIterator2b.Open(*iFont2, glyphIndex2, 
            sizeof(glyphIndex2)/sizeof(glyphIndex2[0]), EFalse);
    TEST(err == KErrNone);   
    ptr1 = glyphIterator2b.Outline();
    len1 = glyphIterator2b.OutlineLength();     
    err = glyphIterator2b.Next();
    TEST(err == KErrNone);
    ptr2 = glyphIterator2b.Outline();
    len2= glyphIterator2b.OutlineLength(); 
    err = glyphIterator2b.Next();
    TEST(err == KErrNone);
    TEST(len1 > 0);  
    TEST(ptr1 == ptr2); 
    TEST(ptr1 != NULL);
    TEST(len1 == len2);
    
    glyphIterator2.Close();
    glyphIterator2b.Close();
    __UHEAP_MARKEND;
    }

/**
    @SYMTestCaseID    TI18N-GDI-CIT-4087
    @SYMTestCaseDesc    Pass invalid font handle to FBS when getting font table.
    @SYMTestActions    Pass invalid font handle to FBS when getting font table.
        And check the return value.
    @SYMTestExpectedResults    Open returns KErrNotFound.
*/
void CTFontAndGlyph::TestFbsFontHandleIsZeroForFont() 
    {
    __UHEAP_MARK;
    CFbsTestForFont* fbsFont = reinterpret_cast<CFbsTestForFont*> (iFont);
    TEST(NULL != fbsFont);
    fbsFont->SetHandle(0);
    TInt handle = fbsFont->Handle();
    CFbsTestForFont tempFsbFont;
    tempFsbFont.Duplicate(handle);
    tempFsbFont.SetHandle(0);    
    RFontTable ft1;
    TInt err = ft1.Open(tempFsbFont, 0x11667730);
    TEST(err == KErrNotFound);
    ft1.Close(); 
    __UHEAP_MARKEND;
    }

/**
    @SYMTestCaseID    TI18N-GDI-CIT-4088
    @SYMTestCaseDesc    Pass invalid font handle to FBS when getting glyph outline.
    @SYMTestActions    Pass invalid font handle to FBS when getting glyph outline.
        And check the return value.
    @SYMTestExpectedResults    Open() returns KErrNotFound.
*/
void CTFontAndGlyph::TestFbsFontHandleIsZeroForGlyph() 
    {
    __UHEAP_MARK;
    CFbsTestForFont* fbsFont = reinterpret_cast<CFbsTestForFont*> (iFont);
    TEST(NULL != fbsFont);
    TInt handle = fbsFont->Handle();
    CFbsTestForFont tempFsbFont;
    tempFsbFont.Duplicate(handle);
    tempFsbFont.SetHandle(0);     
    RGlyphOutlineIterator glyphIterator1;
    TUint glyphIndex[] = {1, 1, KInvalidGlyphId}; 
    TInt err = glyphIterator1.Open(tempFsbFont, glyphIndex, sizeof(glyphIndex)/sizeof(glyphIndex[0]), ETrue);
    TEST(err == KErrNotFound);
    glyphIterator1.Close();    
    __UHEAP_MARKEND;
    }

static TInt OutlinePanicThread(TAny* /* ptr */)
    {   
    CTrapCleanup* trapCleanup=CTrapCleanup::New();
    RGlyphOutlineIterator it;
    it.Outline();
    delete trapCleanup;
    return 0;
    }

static TInt OutlineLengthPanicThread(TAny* /* ptr */)
    {   
    CTrapCleanup* trapCleanup=CTrapCleanup::New();
    RGlyphOutlineIterator it;
    it.OutlineLength();
    delete trapCleanup;
    return 0;
    }

void CTFontAndGlyph::OutlinePanics(TInt (*aThreadFun)(TAny*))
    {   
    __UHEAP_MARK;
    RThread thread;
    TThreadFunction fun(aThreadFun);
    TAny* ptr = NULL;
    thread.Create(_L("RGlyphOutlineIterator"), fun, 0x1000, 0x20000, 0x20000, ptr);
    
    TRequestStatus status;
    thread.Logon(status);
    thread.Resume();
    User::WaitForRequest(status);
    
    TInt err = thread.ExitReason();
    TEST(err == 0);
    TExitCategoryName name = thread.ExitCategory();
    TEST(name == _L("GDI"));    
    thread.Close();
    __UHEAP_MARKEND;
    }


void CTFontAndGlyph::OutlineLengthPanics(TInt (*aThreadFun)(TAny*))
    {   
    __UHEAP_MARK;
    RThread thread;
    TThreadFunction fun(aThreadFun);
    TAny* ptr = NULL;
    thread.Create(_L("RGlyphOutlineLengthIterator"), fun, 0x1000, 0x20000, 0x20000, ptr);
    
    TRequestStatus status;
    thread.Logon(status);
    thread.Resume();  
    User::WaitForRequest(status);
    
    TInt err = thread.ExitReason();
    TEST(err == 0);
    TExitCategoryName name = thread.ExitCategory();
    TEST(name == _L("GDI"));
    thread.Close();
    __UHEAP_MARKEND;
    }

/**
    @SYMTestCaseID    TI18N-GDI-CIT-4089
    @SYMTestCaseDesc    Try to get glyph outline's length and content when 
        the glyph is not found in font file.
    @SYMTestActions    Try to get glyph outline's length and content when 
        the glyph is not found in font file. This should cause a client panic.
    @SYMTestExpectedResults    Both cases exit with ExitCategory 'GDI' and 
    reason code 0.
*/
void CTFontAndGlyph::GlyphOutlineIteratorPanics()
    {
    __UHEAP_MARK;
    OutlinePanics(OutlinePanicThread);
    OutlineLengthPanics(OutlineLengthPanicThread);
    __UHEAP_MARKEND;
    }

void CTFontAndGlyph::ConstructL()
    {    
    INFO_PRINTF1(_L("Calling CTFontAndGlyph::ConstructL()"));
    iFontStore = CFontStore::NewL(&User::Heap());
    LoadOpenFontLibraries(iFontStore);
    iFontStore->iKPixelWidthInTwips = 11860;
    iBmp = new (ELeave) CFbsBitmap;
    User::LeaveIfError(iBmp->Create(TSize(100,100),EGray2));
    iDevice = CFbsBitmapDevice::NewL(iBmp);
    iUid = iFontStore->AddFileL(KTestFontFile);
    TInt err = iDevice->GetNearestFontToMaxHeightInTwips(iFont,iFontSpec,0);
    if (KErrNone != err)
        {
        iFontStore->RemoveFile(iUid);
        User::Leave(err);
        }   
    
    iBmp2 = new (ELeave) CFbsBitmap;  
    User::LeaveIfError(iBmp2->Create(TSize(100,100),EGray2));
    iDevice2 = CFbsBitmapDevice::NewL(iBmp2);
    iUid2 = iFontStore->AddFileL(KTestFontFile2);
    err = iDevice2->GetNearestFontToMaxHeightInTwips(iFont2,iFontSpec2,0);    
    if (KErrNone != err)
        {
        iFontStore->RemoveFile(iUid);
        iFontStore->RemoveFile(iUid2);
        User::Leave(err);
        }
    }

void CTFontAndGlyph::CleanEnv()
    {
    iDevice->ReleaseFont(iFont); 
    delete iDevice;
    delete iBmp;
    iFontStore->RemoveFile(iUid);
    
    iDevice2->ReleaseFont(iFont2); 
    delete iDevice2;
    delete iBmp2;
    iFontStore->RemoveFile(iUid2);
    
    delete iFontStore;
    iDevice = NULL;
    iBmp = NULL;
    iFontStore = NULL;
    
    iDevice2 = NULL;
    iBmp2 = NULL;
    
    REComSession::FinalClose();
    }

//--------------
CTFontAndGlyphStep::CTFontAndGlyphStep()
    {
    SetTestStepName(KTFontTableAndGlyphStep);
    }

CTGraphicsBase* CTFontAndGlyphStep::CreateTestL()
    {
    return new (ELeave) CTFontAndGlyph(this);
    }

static void LoadOpenFontLibraries(CFontStore* aFontStore)
    {

    RImplInfoPtrArray implementationArray;
    TInt error;
    TInt ecomerror;
    TInt ecomnotready;
    TUid uid = {KUidOpenFontRasterizerPlunginInterface};

    // Making sure that no race situation arises
    // If ECom is not ready, give it another chance and try again. if it still doesn't work 
    // after the third try, then it just carries on quietly and fails... 
    for (ecomnotready =0; ecomnotready <3; ecomnotready++)
        {
        TRAP(ecomerror,REComSession::ListImplementationsL(uid,implementationArray));
        if (!ecomerror)
            {
            break;
            }
        else
            {
            ecomerror = 0;  
            User::After(0);
            }
        }

    const TInt availCount = implementationArray.Count();
    for (TInt count=0;count<availCount;++count)
        {
        const CImplementationInformation* info = implementationArray[count];
        TUid rasterizerUid = info->ImplementationUid();
        // Create a rasterizer
        COpenFontRasterizer* rasterizer=0;
        TRAP(error,rasterizer = COpenFontRasterizer::NewL(rasterizerUid));
        if (!error)
            {
            // Install it in the font store.
            TRAP(error,aFontStore->InstallRasterizerL(rasterizer));
            if (error)
                {
                RDebug::Printf("tfonttableandglyph: failed to load rasterizer."); 
                delete rasterizer;
                }
            }
        }
    
    implementationArray.ResetAndDestroy();
    }

/**
Worker function that implements the threads executed by SMPAndWDPSafeTest.
@leave If a leave occurs, either the test failed to be set-up successfully,
    or the test itself failed.
*/
static void DoSMPAndWDPSafeTestFunL()
    {
    User::LeaveIfError(RFbsSession::Connect());
    CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
    CleanupStack::PushL(bmp);
    User::LeaveIfError(bmp->Create(TSize(100,100), EGray2));
    CFbsBitmapDevice* bmpDevice = CFbsBitmapDevice::NewL(bmp);
    CleanupStack::PushL(bmpDevice);
    CFont* font = NULL;
    TFontSpec fontSpec(KTestFontFaceName, KFontHeight);
    User::LeaveIfError(bmpDevice->GetNearestFontToMaxHeightInTwips(font, fontSpec, 0));

    for(TInt i = 0; i < 100; i++)
        {
        RFontTable fontTable;
        CleanupClosePushL(fontTable);
        User::LeaveIfError(fontTable.Open(*font, 0x68656164));
        TUint32* ptr = (TUint32*)fontTable.TableContent();
        if (!ptr)
            {
            User::Leave(KErrGeneral);
            }
        CleanupStack::PopAndDestroy(1); // fontTable;
        }
    bmpDevice->ReleaseFont(font);
    CleanupStack::PopAndDestroy(2); // bmpDevice, bmp
    RFbsSession::Disconnect();
    }

static TInt SMPAndWDPSafeTestFun(TAny* /*aParam*/)
    {
    CTrapCleanup* trapCleanup = CTrapCleanup::New();
    if (!trapCleanup)
        {
        return KErrNoMemory;
        }
    TRAPD(err, DoSMPAndWDPSafeTestFunL());
    delete trapCleanup;
    return err;
    }

/**
    @SYMTestCaseID    TI18N-GDI-CIT-4090
    @SYMTestCaseDesc    Test if the new code is SMP and WDP safe. 
    @SYMTestActions    Create two threads to access the new interfaces concurrently.
    @SYMTestExpectedResults    The threads run to the end correctly. All the
    Open() operations succeed.
*/
void CTFontAndGlyph::SMPAndWDPSafeTest()
    {
    RThread thread1;
    RThread thread2;
    TThreadFunction fun(SMPAndWDPSafeTestFun);
    
    TInt ret1 = thread1.Create(_L("SMPAndWDPSafeThread1"), fun, 0x2000, 0x20000, 0x80000, iFontStore);
	TEST(KErrNone == ret1);
    TInt ret2 = thread2.Create(_L("SMPAndWDPSafeThread2"), fun, 0x2000, 0x20000, 0x80000, iFontStore);
	TEST(KErrNone == ret2);
    
    TRequestStatus status1;
    TRequestStatus status2;
    thread1.Logon(status1);
    thread2.Logon(status2);
    thread1.Resume(); 
    thread2.Resume(); 
    User::WaitForRequest(status1);
    User::WaitForRequest(status2);
    
    TEST(EExitKill == thread1.ExitType());
    TEST(KErrNone == thread1.ExitReason());
    TEST(EExitKill == thread2.ExitType());
    TEST(KErrNone == thread2.ExitReason());
    
    thread1.Close();
    thread2.Close();
    }