/*
* Copyright (c) 2006-2009 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 "T_IsolatedFontStore.h"
#include "openfontsprivate.h"
#include <f32file.h>
#include <e32test.h>
#include <fntstore.h>
#include <f32file.h>
#include <s32file.h>
#include <fbs.h>
#include <graphics/openfontconstants.h>
#include <graphics/openfontrasterizer.h>
#include "T_Cache.H"

LOCAL_C TInt Ptr2Offset(const TAny* aAny, TUint8* aHeapBase)
    {
    if (aAny && aHeapBase)
        {
        return (TInt)aAny - (TInt)aHeapBase;
        }
    return 0;
    }

//LOCAL_C TAny* Offset2Ptr(const TInt aOffset, TUint8* aHeapBase)
//    {
//    if (aOffset && aHeapBase)
//        {
//        return (TAny*)(aOffset + (TInt)aHeapBase);
//        }
//    return NULL;
//    }

CTCache::CTCache(CTestStep* aStep):
    CTGraphicsBase(aStep)
    {
    INFO_PRINTF1(_L("FontStore T_Cache test\n"));
    iHeap=UserHeap::ChunkHeap(NULL,0x1000000,0x1000000);
    }

CTCache::~CTCache()
    {
    iHeap->Close();
    }

//below code is for unit test and coverage only

void CTCache::TFontCache()
    {
#ifdef _DEBUG 
    TFontTableGlyphOutlineCacheMemMonitor mon;
    CFontTableCache* fontCache = new CFontTableCache(iHeap,mon);

    //user array
    TCacheUserInfo* user1 = new TCacheUserInfo(111,0);
    TCacheUserInfo* user2 = new TCacheUserInfo(222,1);    
    RPointerArray<TCacheUserInfo> userArray;
    userArray.Append(user1);
    userArray.Append(user2);    
   
    //item array
    CFontTableCacheItem* item1;
    TInt len = 3;
    TAny* content = (iHeap->Alloc(3));
    TUid iUid = TUid::Uid(123456);
    item1 = new CFontTableCacheItem(iUid, 0x68656164, Ptr2Offset(content, iHeap->Base()), len); 
    item1->SetUser(userArray);    
    RPointerArray<CFontTableCacheItem> itemArray;
    itemArray.Append(item1);
    
    //font cache    
    fontCache->SetFontItem(itemArray);
    TBool has = fontCache->HasOutstandingRefCount();
    TEST(has);
    has = fontCache->HasOutstandingRefCountWithUid(iUid);  
    TEST(has);
    TUid uid = TUid::Uid(1234);
    fontCache->HasOutstandingRefCountWithUid(uid);  //for coverage
    
    TAny *outline = NULL;
    TInt length = 3;
    TInt id = 0;
    TUint32 tag = 0x1234;
    TInt err = fontCache->Find(uid, tag, outline, length, &id);
    TEST(err != KErrNone);
    err = fontCache->Find(iUid, tag, outline, length, &id);
    TEST(err != KErrNone);
    __UHEAP_FAILNEXT(1);
    fontCache->Append(uid, tag, content, length); 
    TEST(err != KErrNone);
    __UHEAP_RESET;
    
    fontCache->CleanupCacheOnFbsSessionTermination(123);
    TEST(err != KErrNone);

    userArray.Close();
    delete fontCache;
    itemArray.Close();
#endif       
    }

void CTCache::TFontCacheItem()
    {  
#ifdef _DEBUG 
    TCacheUserInfo* user1 = new TCacheUserInfo(111,0);
    TCacheUserInfo* user2 = new TCacheUserInfo(222,1);    
    RPointerArray<TCacheUserInfo> userArray;
    userArray.Append(user1);
    userArray.Append(user2);
    
    CFontTableCacheItem* item1;
    TAny* content = User::Alloc(4); 
    TUid iUid = TUid::Uid(123456);
    item1 = new CFontTableCacheItem(iUid, 0x68656164, Ptr2Offset(content, User::Heap().Base()), 3);
    User::Free(content);
    __UHEAP_FAILNEXT(1);
    TInt err = item1->IncRefCount(111);
    TEST(err == KErrNoMemory);
    __UHEAP_RESET;      
    
    TBool has = item1->HasOutstandingRefCount();
    TEST(!has);
    

    item1->SetUser(userArray);
    has = item1->HasOutstandingRefCount();
    TEST(has);
    
    TInt id = 1;
    err = item1->FindUser(333, &id); 
    TEST(err != KErrNone);
    
    err = item1->DecRefCount(333);
    TEST(err == KErrNotFound);
    

    userArray.Close();
    delete item1; 
    
#endif    
    }

void CTCache::TGlyphCacheItem()
    {
#ifdef _DEBUG     
 
    TCacheUserInfo* user1 = new TCacheUserInfo(111,0);
    TCacheUserInfo* user2 = new TCacheUserInfo(222,1);
    
    RPointerArray<TCacheUserInfo> userArray;
    userArray.Append(user1);
    userArray.Append(user2);
    
    COutlineCacheItem* item1;
    TInt len = 3;
    TAny* content = User::Alloc(4); 
    item1 = new COutlineCacheItem(Ptr2Offset(content, User::Heap().Base()), len);
    User::Free(content);
    __UHEAP_FAILNEXT(1);
    TInt err = item1->DecRefCount(333);
    err = item1->IncRefCount(111);
    TEST(err == KErrNoMemory);
    __UHEAP_RESET;      
    

    item1->SetUser(userArray);    
    err = item1->IncRefCount(333);
    TEST(err == KErrNone);
  
    userArray.Close();
    delete item1;   
#endif  
    }

void CTCache::THintedGlyphCache()
    {
#ifdef _DEBUG 
    TFontTableGlyphOutlineCacheMemMonitor mon;
    CHintedOutlineCache* hintedCache = new CHintedOutlineCache(iHeap,mon);
    TCacheUserInfo* user1 = new TCacheUserInfo(111,0);
    TCacheUserInfo* user2 = new TCacheUserInfo(222,1);    
    RPointerArray<TCacheUserInfo> userArray;
    userArray.Append(user1);
    userArray.Append(user2);    
    COutlineCacheItem* item1;
    TInt len = 4;
    //TUint content[] = {1,2,3};
    TAny* content = User::Alloc(4); 
    item1 = new COutlineCacheItem(Ptr2Offset(content, User::Heap().Base()), len);
    item1->SetUser(userArray); 
    COpenFont* openFont = NULL;
    THintedOutlineId hintedId(openFont, 11);
    hintedCache->SetHintedItem(hintedId, item1);
    RHashMap<THintedOutlineId, COutlineCacheItem*> map = hintedCache->GetHintedMap();
    //for coverage
    THintedOutlineId hintedId1(openFont, 12);
    TInt err = hintedCache->IncRefCount(hintedId1, 111);
    TEST(err != KErrNone);
    COpenFont* openFont1 = reinterpret_cast<COpenFont*>(0x123);
    //for coverage
    err = hintedCache->CleanupCacheOnOpenFontRemoval(openFont1);
    TEST(err == KErrNone);
    //following return value alway KErrNone
    hintedCache->CleanupCacheOnFbsSessionTermination(111);
    hintedCache->CleanupCacheOnFbsSessionTermination(333);
    
    TAny* ptr;
    TInt size = 0;
    __UHEAP_FAILNEXT(1);
    hintedCache->CacheHintedOutline(hintedId1, &content, len, ptr, size);  
    __UHEAP_RESET;
    
    __RHEAP_FAILNEXT(iHeap, 1);
    hintedCache->CacheHintedOutline(hintedId1, &content, len, ptr, size);
    __RHEAP_RESET(iHeap);
    

    mon.Inc(KFontTable_GlyphOutline_CacheMaxMem);
    err = hintedCache->CacheHintedOutline(hintedId1, &content, len, ptr, len); 
    TEST(err == KErrNoMemory);
    User::Free(content);
    
    map.Close();
    delete item1;
    userArray.Close();
    delete hintedCache;    
#endif      
    }

void CTCache::TUnHintedGlyphCache()
    {
#ifdef _DEBUG 
    TFontTableGlyphOutlineCacheMemMonitor mon;
    CUnhintedOutlineCache* unhintedCache = new CUnhintedOutlineCache(iHeap,mon);
    TCacheUserInfo* user1 = new TCacheUserInfo(111,0);
    TCacheUserInfo* user2 = new TCacheUserInfo(222,1);    
    RPointerArray<TCacheUserInfo> userArray;
    userArray.Append(user1);
    userArray.Append(user2);    
    COutlineCacheItem* item1;
    TInt len = 3;
    TAny* content = (iHeap->Alloc(3));  
    item1 = new COutlineCacheItem(Ptr2Offset(content, iHeap->Base()), len);
    item1->SetUser(userArray); 
    TUid uid = TUid::Uid(123);
    TUnhintedOutlineId unhintedId(uid, 11, 1);
    unhintedCache->SetUnHintedItem(unhintedId, item1);
//    RHashMap<TUnhintedOutlineId, COutlineCacheItem*> map = unhintedCache->GetHintedMap();
    TUnhintedOutlineId unhintedId1(uid, 12, 1);
    TInt err = unhintedCache->IncRefCount(unhintedId1, 111);
    TEST(err != KErrNone);
    //for coverage
    unhintedCache->CleanupCacheOnFbsSessionTermination(111);
    unhintedCache->CleanupCacheOnFbsSessionTermination(333);
    
    TAny* ptr;
    TInt size = 0;
    __UHEAP_FAILNEXT(1);
    unhintedCache->CacheUnhintedOutline(unhintedId1, &content, len, ptr, size);  
    __UHEAP_RESET;
    
    __RHEAP_FAILNEXT(iHeap, 1);
    unhintedCache->CacheUnhintedOutline(unhintedId1, &content, len, ptr, size);
    __RHEAP_RESET(iHeap);
    
    
    mon.Inc(KFontTable_GlyphOutline_CacheMaxMem);
    err = unhintedCache->CacheUnhintedOutline(unhintedId1, &content, len, ptr, len); 
    TEST(err == KErrNoMemory);
    
    userArray.Close();
    delete unhintedCache; 

#endif   
    }

void CTCache::TFontCacheForCov()
    {
#ifdef _DEBUG 
    TFontTableGlyphOutlineCacheMemMonitor mon;
    CFontTableCache* fontCache = new CFontTableCache(iHeap,mon);

    TCacheUserInfo* user1 = new TCacheUserInfo(111,0);
    RPointerArray<TCacheUserInfo> userArray;
    userArray.Append(user1);
    CFontTableCacheItem* item1;
    TInt len = 3;
    TAny* content = (iHeap->Alloc(3));   
    TUid iUid = TUid::Uid(123456);
    item1 = new CFontTableCacheItem(iUid, 0x68656164, Ptr2Offset(content, iHeap->Base()), len); 
    item1->SetUser(userArray);    
    RPointerArray<CFontTableCacheItem> itemArray;
    itemArray.Append(item1);
    fontCache->SetFontItem(itemArray);
    
    TBool has = fontCache->HasOutstandingRefCount();
    TEST(!has);
    has = fontCache->HasOutstandingRefCountWithUid(iUid);  
    TEST(!has);
    
    TUint length = 3;
    TUint32 tag = 0x1234;
    TUid uid = TUid::Uid(1234);
    mon.Inc(KFontTable_GlyphOutline_CacheMaxMem);
    TInt err = fontCache->Append(uid, tag, content, length); 
    TEST(err == KErrNoMemory);

    userArray.Close();
    delete fontCache;
    itemArray.Close();
#endif       
    }

void CTCache::RunTestCaseL(TInt aCurTestCase)
    {
    ((CTCacheStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
    switch(aCurTestCase)
        {
    case 1:
        ((CTCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-Cache-0001"));
        INFO_PRINTF1(_L("FontStore T_Cache test 1: TFontCacheItem\n"));
        TFontCacheItem();
        break;
        
    case 2:
        ((CTCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-Cache-0002"));
        INFO_PRINTF1(_L("FontStore T_Cache test 2: TFontCache\n"));
        TFontCache();
        TFontCacheForCov();
        break;      
        
    case 3:
        ((CTCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-Cache-0003"));
        INFO_PRINTF1(_L("FontStore T_Cache test 3: THintedGlyphCacheItem\n"));
        TGlyphCacheItem();
        break;  
        
    case 4:
        ((CTCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-Cache-0004"));
        INFO_PRINTF1(_L("FontStore T_Cache test 4: THintedGlyphCache\n"));
        THintedGlyphCache();
        break;  

    case 5:
        ((CTCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-Cache-0005"));
        INFO_PRINTF1(_L("FontStore T_Cache test 5: TUnHintedGlyphCache\n"));
        TUnHintedGlyphCache();
        break; 
        
    case 6:
        ((CTCacheStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
        ((CTCacheStep*)iStep)->CloseTMSGraphicsStep();
        TestComplete();             
        break;
        }
    ((CTCacheStep*)iStep)->RecordTestResultL();
    }

//--------------
__CONSTRUCT_STEP__(Cache)