/*
* Copyright (c) 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:
*
*/
/*
 * T_cahswidgetscanner.cpp
 *
 *  Created on: 2009-09-16
 *      Author:
 */

//  CLASS HEADER


#include <ecom/ecom.h>
#include <QScopedPointer>
#include <utf.h>
#include <xml/dom/xmlengdocument.h>
#include <XQConversions>
#include <usif/sif/sifcommon.h>
#include <usif/sif/sif.h>
#include <xmlengelement.h>
#include <driveinfo.h>

#include "t_cawidgetscanner.h"
#include "cawidgetscannertestutils.h"
#include "waitactive.h"
#include "casrvengutils.h"
#include "castorageproxy.h"
#include "casrvmanager.h"
#include "casrvplugin.h"
#include "cainnerentry.h"
#include "cainnerquery.h"
#include "caarraycleanup.inl"
#include "testconsts.h"
#include "cadef.h"
#include "castorage_global.h"

#include "cawidgetscannerparser.h"
#include "cawidgetstoragehandler.h"
#include "cawidgetscannerplugin.h"
#include "cawidgetscannerdef.h"
#include "WidgetScannerUtils.h"


#include "t_cainstaller.h"

const TUid KHsWidgetPluginUid = {0x20026FB1};
const TInt installedUid = 0x20053785;

_LIT8( KSisxMimeType, "x-epoc/x-sisx-app" );
_LIT( KTestLibrary, "C:\\private\\20022F35\\import\\widgetregistry\\20053785\\testwidget" );
_LIT8( KWidgetUID, "testwidgetprovider.dll" );
_LIT( KWidgetLibrary2, "C:\\private\\20022F35\\import\\widgetregistry\\20053785\\testwidget22" );
_LIT( KWidgetLibrary3, "C:\\private\\20022F35\\import\\widgetregistry\\20053785\\testwidget33" );

_LIT( KWidget1PackageName, "c:\\testing\\data\\Installs\\validwidget1.SISX" );
_LIT( KWidget2PackageName, "c:\\testing\\data\\Installs\\validwidget2.SISX" );
_LIT( KWidget3PackageName, "c:\\testing\\data\\Installs\\validwidget3.SISX" );
_LIT( KWidget4PackageName, "c:\\testing\\data\\Installs\\validwidget4.SISX" );
_LIT( KWidget1ManifestName, "C:\\private\\20022F35\\import\\widgetregistry\\20053785\\validwidget1.manifest" );
_LIT( KWidget2ManifestName, "C:\\private\\20022F35\\import\\widgetregistry\\20053785\\validwidget2.manifest" );
_LIT( KWidget3ManifestName, "C:\\private\\20022F35\\import\\widgetregistry\\20053785\\validwidget3.manifest" );
_LIT( KWidget4ManifestName, "C:\\private\\20022F35\\import\\widgetregistry\\20053785\\validwidget4.manifest" );
_LIT( KWidgetQmFolder, "c:\\resource\\qt\\translations\\" );
_LIT( KWidgetQmFolderAndFile, "c:\\resource\\qt\\translations\\" );
_LIT( KWidgetQmFile, "c:\\testing\\data\\t_cawidgetscanner\\widgettranslation_en_GB.qm" );
_LIT( KWidgetUri1, "testwidget" );
_LIT( KWidgetUri2, "testwidget22" );
_LIT( KWidgetUri3, "testwidget33" );
_LIT( KWidgetUri4, "testwidget44" );
_LIT( KTranslationFileNameAsInManifest, "widgettranslation" );

template <typename RClass>
struct RClassDeleter
{
    static inline void cleanup(RClass *ptr)
    {
        ptr->Close();
    }
};

typedef QScopedPointer<RBuf, 
    RClassDeleter<RBuf> > RBufGuard;
typedef QScopedPointer<RBuf8, 
    RClassDeleter<RBuf8> > RBuf8Guard;
        
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::WaitL(TInt aMicroSec)
    {
    CWaitActive* wait = CWaitActive::NewL();
    wait->Wait(aMicroSec);
    delete wait;
    }

void T_CaWidgetScanner::initTestCase()
    {
    const TUid KWidgetHandlerPluginUid = {0x20028707};
    TRAPD(err,
        iTestUtils = CTestUtils::NewL();
        iTestUtils->CopyDb();

        // remove hswidget
        iStorage = CCaStorageProxy::NewL();
        iSrvEngUtils = CCaSrvEngUtils::NewL();
        iScr = new Usif::RSoftwareComponentRegistry;
        User::LeaveIfError(iScr->Connect());

        iFs.Connect();
        iImportPath.CreateL( KMaxPath );

        createImportDirectoryL();
        
        iInstaller = T_CaInstaller::NewL();
        TPluginParams params;
        params.engUtils = iSrvEngUtils;
        params.storageProxy = iStorage;
        params.softwareRegistry = iScr;
        iPlugin = iTestUtils->LoadPluginL( KWidgetHandlerPluginUid, &params);
        
        );
    }

void T_CaWidgetScanner::cleanupTestCase()
    {
    QTest::qWait(5000);
    
    iTestUtils->RemoveL(KTestDbDest);
    delete iPlugin;
    delete iInstaller;
    delete iStorage;
    iStorage = NULL;
    delete iTestUtils;
    iTestUtils = NULL;
    delete iSrvEngUtils;
    iSrvEngUtils = NULL;
    iScr->Close();
    delete iScr;
    iScr = NULL;
    iFs.Close();
    REComSession::FinalClose();
    iImportPath.Close();
    iWidgetScanFolder.Close();
    
    iWidgetScanFile1.Close();
    }


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::init()
    {
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::cleanup()
    {
	QTest::qWait(100);
    }



void T_CaWidgetScanner::createImportDirectoryL()
    {
    //create "parsed" directory if it doesn't exist yet;
    // create directory on C: drive
    iWidgetScanFolder.Close();
    iWidgetScanFile1.Close();
    iWidgetScanFolder.CreateL(KMaxPath);
    iWidgetScanFile1.CreateL(KMaxPath);
    iWidgetScanFolder.Append( KPrivate );
    iWidgetScanFolder.Append( KHSWidgetScanFolder );
    iWidgetScanFile1.Append(iWidgetScanFolder);
    iWidgetScanFile1.Append(KManifestFile1);
    }

//
// TESTS  --------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//

void T_CaWidgetScanner::testPluginNewL()
{
//Check only if plugin was created correctly
    QVERIFY( iPlugin != NULL);
}


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//


void T_CaWidgetScanner::testAddWidget()
    {
    bool widgetExistsInStorage(false);
    TInt err(KErrNone);
    
    
    TRAP_IGNORE(iInstaller->InstallL(KWidget1PackageName));
    
    QTest::qWait(3000);

    TRAP_IGNORE(widgetExistsInStorage = ( iTestUtils->WidgetExistsInStorageL(
          KAttrWidgetLibrary, KTestLibrary, iStorage ) != EFalse ));
    
    // clean after test
    TRAP_IGNORE(iInstaller->UninstallL(KWidget1ManifestName))
    QTest::qWait(3000);
    
    QVERIFY(widgetExistsInStorage);
    }


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::testUpdateWidget()
    {
	TInt err(KErrNone);

    TRAP(err,
    		testUpdateWidgetTrapped()
        );
    }
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::testUpdateWidgetTrapped()
	{
    TInt err(KErrNone);
    
    TInt expectedCount(0);
    TInt actualCount(0);
    bool widgetAExistsInStorage(false);
    bool widgetBExistsInStorage(false);

    iInstaller->InstallL(KWidget2PackageName);
    
    QTest::qWait(3000);

    expectedCount = iTestUtils->WidgetsCountL(iStorage);

    widgetAExistsInStorage = (iTestUtils->WidgetExistsInStorageL(
            KAttrWidgetLibrary, KWidgetLibrary2, iStorage) != FALSE);


    iInstaller->InstallL(KWidget3PackageName);
    QTest::qWait(3000);

    widgetBExistsInStorage = (iTestUtils->WidgetExistsInStorageL(
            KAttrWidgetUri, KWidgetUri2, iStorage) != FALSE);

    actualCount = iTestUtils->WidgetsCountL(iStorage);
    TRAP_IGNORE(iInstaller->UninstallL(KWidget2ManifestName))
    QTest::qWait(3000);
    TRAP_IGNORE(iInstaller->UninstallL(KWidget3ManifestName))
    QTest::qWait(3000);
    
    QCOMPARE(err, KErrNone);
    QVERIFY(widgetAExistsInStorage);
    QVERIFY(widgetBExistsInStorage);
    QCOMPARE(actualCount, expectedCount);
	}


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::testRemoveMmcWidget()
    {
    TInt err(KErrNone);
    TInt id(KErrNotFound);
    bool widgetExistsInStorage(false);
    bool mmcIdAttributeSet1(false);
    bool mmcIdAttributeSet2(false);
    
    TRAP(err,

        //test
        iInstaller->InstallL(KWidget1PackageName);
        QTest::qWait(3000);

        id = AppendMmcIdL(_L("TestWidget"));

        mmcIdAttributeSet1 = MmcAttributeSetL(id);
        
        // after unistall mmc id should be removed
        iInstaller->UninstallL(KWidget1ManifestName);
        
        QTest::qWait(3000);
        
        mmcIdAttributeSet2 = MmcAttributeSetL(id);

    );
    
    QCOMPARE(err, KErrNone);
    QVERIFY(mmcIdAttributeSet1);
    QVERIFY(!mmcIdAttributeSet2);
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::testUpdateTheSameWidget()
	{
    TInt err(KErrNone);
    TRAP(err,
		testUpdateTheSameWidgetTrapped()
    );

	}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::testUpdateTheSameWidgetTrapped()
    {
    _LIT( KWText, "TestWidget" );
    TUint flags0(0U);
    TUint flags1(0U);
    TUint flags2(0U);
    TInt err(KErrNone); 
    TInt expectedCount(0);
    TInt actualCount(0);
	
    iInstaller->InstallL( KWidget1PackageName );
        
    QTest::qWait(3000);

    flags0 = iTestUtils->GetWidgetFlagsL( KWText, iStorage );

    expectedCount = iTestUtils->WidgetsCountL( iStorage );

    CCaWidgetDescription* widget = iTestUtils->GetWidgetEntryL( KWText, iStorage );
        
    if (widget == NULL)
    {
        User::Leave(KErrNotFound);
    }
        
    CleanupStack::PushL( widget );
    CCaInnerEntry* innerEntry = widget->GetEntryLC();
    iStorage->TouchL( innerEntry );
    QTest::qWait( 500 );

    flags1 = iTestUtils->GetWidgetFlagsL( KWText, iStorage );

    iInstaller->InstallL( KWidget1PackageName );
    QTest::qWait(3000);

    flags2 = iTestUtils->GetWidgetFlagsL( KWText, iStorage );

    actualCount = iTestUtils->WidgetsCountL(iStorage);
        
    CleanupStack::PopAndDestroy( innerEntry );
    CleanupStack::PopAndDestroy( widget );
        

    // clean after test
    iInstaller->UninstallL(KWidget1ManifestName);
    QTest::qWait(3000);
//    QCOMPARE(err, KErrNone);
    QVERIFY( ~(flags0 & EUsed) );
    QVERIFY( (flags1 & EUsed) );
    QVERIFY( ~(flags2 & EUsed) );
    QCOMPARE(actualCount, expectedCount);
    }


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::testUpdateMmcRemoveInsertTrapped()
    {
    _LIT( KWTextCanNotTranslate, "txt_applib_subtitle_downloads" );
    TPluginParams params;
    params.engUtils = 0;
    params.storageProxy = iStorage;
    params.softwareRegistry = iScr;
    _LIT( KWTextTranslated, "Downloads" );
    TUint flags0(0U);
    TUint flags1(0U);
    TUint flags2(0U);
    TUint flags3(0U);
    TInt err(KErrNone);
    

            
        iTestUtils->Copy( KWidgetQmFile, KWidgetQmFolder );    

        CCaWidgetStorageHandler* handler = CCaWidgetStorageHandler::NewL(
                iStorage, *iScr, iFs );

        iInstaller->InstallL( KWidget2PackageName );
        QTest::qWait(3000);
        //get translated widget
        RBuf widgetName;
        widgetName.CreateL( KWTextTranslated );
        CCaWidgetDescription* widget = iTestUtils->GetWidgetEntryL( 
                KWTextTranslated, iStorage );
        if( !widget )
            {
            widgetName.Close();
            widgetName.CreateL( KWTextCanNotTranslate );
            //qm file has not found
            widget = iTestUtils->GetWidgetEntryL( 
                    KWTextCanNotTranslate, iStorage );
            }
        flags0 = iTestUtils->GetWidgetFlagsL( widgetName, iStorage );
        CleanupStack::PushL( widget );
        CCaInnerEntry* innerEntry = widget->GetEntryLC();
        iStorage->TouchL( innerEntry );
        QTest::qWait( 500 );

        flags1 = iTestUtils->GetWidgetFlagsL( widgetName, iStorage );

        CCaWidgetDescription* widget2 = iTestUtils->GetWidgetEntryL( widgetName, iStorage );
        CleanupStack::PushL( widget2 );

        // set missing
        handler->SetMissingFlagL( widget2 );
        flags2 = iTestUtils->GetWidgetFlagsL( widgetName, iStorage );

        iInstaller->InstallL( KWidget2PackageName );
        QTest::qWait( 4000 );

        flags3 = iTestUtils->GetWidgetFlagsL( widgetName, iStorage );
        widgetName.Close();
        CleanupStack::PopAndDestroy( widget2 );
        CleanupStack::PopAndDestroy( innerEntry );
        CleanupStack::PopAndDestroy( widget );
        iTestUtils->RemoveL( KWidgetQmFolderAndFile );        


    // clean after test
    iInstaller->UninstallL(KWidget2ManifestName);

    QTest::qWait(3000);
    QCOMPARE(err, KErrNone);
    QVERIFY( ~(flags0 & EUsed) );
    QVERIFY( flags1 & EUsed );
    QVERIFY( ~(flags1 & EMissing) );
    QVERIFY( flags2 & EUsed );
    QVERIFY( flags2 & EMissing );
    QVERIFY( flags3 & ~EUsed );
    QVERIFY( flags3 & ~EMissing );
    }

void T_CaWidgetScanner::testUpdateMmcRemoveInsert()
    {
    TInt err(KErrNone);
    TRAP(err,
    		testUpdateMmcRemoveInsertTrapped()
    );
    }
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::testRemoveWidget()
    {
    TInt err(KErrNone);
    bool widgetExistedInStorage(false);
    bool widgetRemovedFromStorage(false);
    
	
    TRAP(err,
        
        iInstaller->InstallL(KWidget1PackageName);

        QTest::qWait(3000);

        widgetExistedInStorage =( iTestUtils->WidgetExistsInStorageL(
                KAttrWidgetLibrary, KTestLibrary, iStorage ) != FALSE);

        iInstaller->UninstallL(KWidget1ManifestName);
        
        QTest::qWait(3000);

        widgetRemovedFromStorage = ((iTestUtils->WidgetExistsInStorageL(
                KAttrWidgetLibrary, KTestLibrary, iStorage )) != FALSE);


        );

    QCOMPARE(err, KErrNone);
    QVERIFY(widgetExistedInStorage);
    QVERIFY(widgetRemovedFromStorage);
    }


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::testSetMissingFlag()
    {
    _LIT( KWText, "TestWidget" );

    TInt err(KErrNone);
    TUint flags(0U);
	
    TRAP(err,

        CCaWidgetStorageHandler* handler = CCaWidgetStorageHandler::NewL(
                iStorage, *iScr, iFs);
        iInstaller->InstallL(KWidget1PackageName);
        QTest::qWait(3000);

        CCaWidgetDescription* widget = iTestUtils->GetWidgetEntryL( KWText, iStorage);
        handler->SetMissingFlagL( widget );
        delete widget;

        flags = iTestUtils->GetWidgetFlagsL(KWText, iStorage);
        
        delete handler;
    );
    
    // clean after test
    TRAP_IGNORE(iInstaller->UninstallL(KWidget1ManifestName));
    QTest::qWait(3000);
    QCOMPARE(err, KErrNone);
    QVERIFY( flags & EMissing );
    QVERIFY( ~(flags & EVisible) );
   }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::testSetLocalizationsL()
    {
    CCaWidgetDescription* widget = CCaWidgetDescription::NewLC();
    widget->SetUriL(KWidgetUri1());
    widget->SetTranslationFileNameL(KTranslationFileNameAsInManifest());
    widget->SetTitleL( _L("txt_applib_subtitle_downloads") );
    
    widget->LocalizeTextsL();
    
    QVERIFY(!widget->GetStringIdTitle().Compare(_L("txt_applib_subtitle_downloads")));
    QVERIFY(!widget->GetStringIdDescription().Compare( KNullDesC ));
    
    RPointerArray<CCaLocalizationEntry> resultContainer;
    CleanupResetAndDestroyPushL( resultContainer );
    iStorage->GetLocalizationsL( resultContainer );
    int a = resultContainer.Count();
    resultContainer.Reset();
    
    CCaWidgetStorageHandler* handler = CCaWidgetStorageHandler::NewL(
            iStorage, *iScr, iFs );
    
    widget->SetStringidTitleL( _L("titleId") );    
    handler->SetLocalizationsL( widget, 2000 );
    
    iStorage->GetLocalizationsL( resultContainer );
    int b = resultContainer.Count();
    
    QCOMPARE( a+1, b );
    
    delete handler;    
    CleanupStack::PopAndDestroy( &resultContainer );
    CleanupStack::PopAndDestroy( widget );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::testUtils()
    {
    RBuf mmcId;
    mmcId.CleanupClosePushL();
    mmcId.CreateL(KMassStorageIdLength);
    WidgetScannerUtils::CurrentMmcId(iFs, mmcId);
    TInt mmcDrive;
    if( DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage,
            mmcDrive ) == KErrNone )
        {
        QVERIFY(mmcId.Length() > 0);
        }
    
    CleanupStack::PopAndDestroy( &mmcId );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::testParsePreviewImageName()
{
    TInt err(KErrNone);
    TChar drive = 'c';

    RBuf expectedPreviewFileName;
    RBufGuard expectedPreviewFileNameGuard(&expectedPreviewFileName);
    
    QScopedPointer < CCaWidgetScannerParser > parser;
    QScopedPointer < CCaWidgetDescription > widgetDescriptor;
    QT_TRAP_THROWING(parser.reset(CCaWidgetScannerParser::NewL(iFs)));
    QT_TRAP_THROWING(widgetDescriptor.reset( CCaWidgetDescription::NewL()) );
    
    _LIT8( KPreviewFileName8, "preview.png" );
    _LIT( KPreviewFileName, "preview.png" );
    _LIT( KWidgetPackageId, "12345678" );
    
    TXmlEngElement element;

    TRAP(err,
        RXmlEngDOMImplementation domImpl;
        CleanupClosePushL(domImpl);
        domImpl.OpenL();
        RXmlEngDocument doc;
        CleanupClosePushL(doc);
        doc.OpenL(domImpl);
        TXmlEngElement element = 
            doc.CreateDocumentElementL(KPreviewImageElementName());
        element.AddTextL(KPreviewFileName8());
        parser->ParsePreviewImageNameL( element, KWidgetPackageId(),
                widgetDescriptor.data(), drive);
        CleanupStack::PopAndDestroy(&doc);
        CleanupStack::PopAndDestroy(&domImpl);
        );
        

    QCOMPARE(err, KErrNone);

    TRAP(err,
        HBufC *manifestPath = parser->GetManifestDirectoryPathLC(
                KWidgetPackageId(), drive );
        expectedPreviewFileName.CreateL(manifestPath->Length() +
                KPreviewFileName().Length());
        expectedPreviewFileName.Append(*manifestPath);
        expectedPreviewFileName.Append(KPreviewFileName());
        CleanupStack::PopAndDestroy( manifestPath );
    );
    QCOMPARE(err, KErrNone);
    {
        const QString exp = XQConversions::s60DescToQString(expectedPreviewFileName);
        const QString act = 
            XQConversions::s60DescToQString(
                widgetDescriptor->GetPreviewImageName());
        QCOMPARE(exp, act);    
    }
    
    RBuf expectedPreviewSkinId;
    RBufGuard expectedPreviewSkinIdGuard(&expectedPreviewSkinId);

    _LIT8( KPreviewSkinId, "skin_id" );
    
    TRAP(err,
        RXmlEngDOMImplementation domImpl;
        CleanupClosePushL(domImpl);
        domImpl.OpenL();
        RXmlEngDocument doc;
        CleanupClosePushL(doc);
        doc.OpenL(domImpl);
        
        TXmlEngElement element = 
            doc.CreateDocumentElementL(KPreviewImageElementName());
        element.AddTextL(KPreviewSkinId());
        parser->ParsePreviewImageNameL( element, KWidgetPackageId(),
                widgetDescriptor.data(), drive);
        CleanupStack::PopAndDestroy(&doc);
        CleanupStack::PopAndDestroy(&domImpl);
        );
    
    QCOMPARE(err, KErrNone);

    TRAP(err,
        expectedPreviewSkinId.Assign(
            CnvUtfConverter::ConvertToUnicodeFromUtf8L(KPreviewSkinId()));
    );
    QCOMPARE(err, KErrNone);
    {
        const QString exp = XQConversions::s60DescToQString(expectedPreviewSkinId);
        const QString act = 
            XQConversions::s60DescToQString(
                widgetDescriptor->GetPreviewImageName());
        
        QCOMPARE(exp, act);    
    }
    
    RBuf8 attributeValueTooLong;
    RBuf8Guard attributeValueTooLongGuard(&attributeValueTooLong);
    attributeValueTooLong.CreateL(KCaMaxAttrValueLen + 1);
    
    for (int i = KCaMaxAttrValueLen; i >= 0 ; --i)
    {
        attributeValueTooLong.Append(_L8("a"));
    }
    
    TRAP(err,
        RXmlEngDOMImplementation domImpl;
        CleanupClosePushL(domImpl);
        domImpl.OpenL();
        RXmlEngDocument doc;
        CleanupClosePushL(doc);
        doc.OpenL(domImpl);
        
        TXmlEngElement element = 
            doc.CreateDocumentElementL(KPreviewImageElementName());
        element.AddTextL(attributeValueTooLong);

        parser->ParsePreviewImageNameL( element, KWidgetPackageId(),
            widgetDescriptor.data(), drive);
        CleanupStack::PopAndDestroy(&doc);
        CleanupStack::PopAndDestroy(&domImpl);
        );
    
    QCOMPARE(err, KErrNone);
    {
        QCOMPARE(widgetDescriptor->GetPreviewImageName().Length(), 
            KCaMaxAttrValueLen + 1);    
    }
    
    TRAP(err,
        RXmlEngDOMImplementation domImpl;
        CleanupClosePushL(domImpl);
        domImpl.OpenL();
        RXmlEngDocument doc;
        CleanupClosePushL(doc);
        doc.OpenL(domImpl);
        
        TXmlEngElement element = 
            doc.CreateDocumentElementL(KPreviewImageElementName());
        element.AddTextL(KNullDesC8);

        parser->ParsePreviewImageNameL( element, KWidgetPackageId(),
            widgetDescriptor.data(), drive);
        CleanupStack::PopAndDestroy(&doc);
        CleanupStack::PopAndDestroy(&domImpl);
        );
    
    QCOMPARE(err, KErrNone);
    {
        const QString exp = XQConversions::s60DescToQString(KNullDesC);;
        const QString act = XQConversions::s60DescToQString(
            widgetDescriptor->GetPreviewImageName());
        QCOMPARE(exp, act);    
    }
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void T_CaWidgetScanner::testParseIconName()
{
    TInt err(KErrNone);

    TChar drive = 'c';
    
    RBuf expectedIconFileName;
    RBufGuard expectedIconFileNameGuard(&expectedIconFileName);
    
    QScopedPointer < CCaWidgetScannerParser > parser;
    QScopedPointer < CCaWidgetDescription > widgetDescriptor;
    QT_TRAP_THROWING(parser.reset(CCaWidgetScannerParser::NewL(iFs)));
    QT_TRAP_THROWING(widgetDescriptor.reset( CCaWidgetDescription::NewL()) );
    
    _LIT8( KIconName8, "preview.png" );
    _LIT( KIconName, "preview.png" );
    _LIT( KWidgetPackageId, "12345678" );
    TXmlEngElement element;

    TRAP(err,
        RXmlEngDOMImplementation domImpl;
        CleanupClosePushL(domImpl);
        domImpl.OpenL();
        RXmlEngDocument doc;
        CleanupClosePushL(doc);
        doc.OpenL(domImpl);
        TXmlEngElement element = 
            doc.CreateDocumentElementL(KIcon());
        element.AddTextL(KIconName8());
        parser->ParseIconL( element, KWidgetPackageId(), widgetDescriptor.data(), drive );
        CleanupStack::PopAndDestroy(&doc);
        CleanupStack::PopAndDestroy(&domImpl);
        );
        

    QCOMPARE(err, KErrNone);

    TRAP(err,
        HBufC *manifestPath = parser->GetManifestDirectoryPathLC( KWidgetPackageId(), drive );
        expectedIconFileName.CreateL(manifestPath->Length() + KIconName().Length());
        expectedIconFileName.Append(*manifestPath);
        expectedIconFileName.Append(KIconName());
        CleanupStack::PopAndDestroy(manifestPath);
    );
    QCOMPARE(err, KErrNone);
    {
        const QString exp = XQConversions::s60DescToQString(expectedIconFileName);
        const QString act = 
            XQConversions::s60DescToQString(
                widgetDescriptor->GetIconUri());
        QCOMPARE(exp, act);    
    }
    
    RBuf expectedIconSkinId;
    RBufGuard expectedIconSkinIdGuard(&expectedIconSkinId);

    _LIT8( KIconSkinId, "skin_id" );
    
    TRAP(err,
        RXmlEngDOMImplementation domImpl;
        CleanupClosePushL(domImpl);
        domImpl.OpenL();
        RXmlEngDocument doc;
        CleanupClosePushL(doc);
        doc.OpenL(domImpl);
        
        TXmlEngElement element = 
            doc.CreateDocumentElementL(KIcon());
        element.AddTextL(KIconSkinId());

        parser->ParseIconL(element, KWidgetPackageId(),  widgetDescriptor.data(), drive);
        CleanupStack::PopAndDestroy(&doc);
        CleanupStack::PopAndDestroy(&domImpl);
        );
    
    QCOMPARE(err, KErrNone);

    TRAP(err,
        expectedIconSkinId.Assign(
            CnvUtfConverter::ConvertToUnicodeFromUtf8L(KIconSkinId()));
    );
    QCOMPARE(err, KErrNone);
    {
        const QString exp = XQConversions::s60DescToQString(expectedIconSkinId);
        const QString act = 
            XQConversions::s60DescToQString(
                widgetDescriptor->GetIconUri());
        
        QCOMPARE(exp, act);    
    }
    
    RBuf8 veryLongAttributeValue;
    RBuf8Guard veryLongAttributeValueGuard(&veryLongAttributeValue);
    veryLongAttributeValue.CreateL(KCaMaxAttrValueLen + 1);
    
    for (int i = KCaMaxAttrValueLen; i >= 0 ; --i)
    {
        veryLongAttributeValue.Append(_L8("a"));
    }
    
    TRAP(err,
        RXmlEngDOMImplementation domImpl;
        CleanupClosePushL(domImpl);
        domImpl.OpenL();
        RXmlEngDocument doc;
        CleanupClosePushL(doc);
        doc.OpenL(domImpl);
        
        TXmlEngElement element = 
            doc.CreateDocumentElementL(KIcon());
        element.AddTextL(veryLongAttributeValue);

        parser->ParseIconL(element, KWidgetPackageId(),  widgetDescriptor.data(), drive );
        CleanupStack::PopAndDestroy(&doc);
        CleanupStack::PopAndDestroy(&domImpl);
        );
    
    QCOMPARE(err, KErrNone);

    {
        QCOMPARE(widgetDescriptor->GetIconUri().Length(), 
            KCaMaxAttrValueLen + 1);    
    }
    
    TRAP(err,
        RXmlEngDOMImplementation domImpl;
        CleanupClosePushL(domImpl);
        domImpl.OpenL();
        RXmlEngDocument doc;
        CleanupClosePushL(doc);
        doc.OpenL(domImpl);
        
        TXmlEngElement element = 
            doc.CreateDocumentElementL(KIcon());
        element.AddTextL(KNullDesC8);

        parser->ParseIconL(element, KWidgetPackageId(),  widgetDescriptor.data(), drive );
        CleanupStack::PopAndDestroy(&doc);
        CleanupStack::PopAndDestroy(&domImpl);
        );
    
    QCOMPARE(err, KErrNone);
    {
        const QString exp = XQConversions::s60DescToQString(KNullDesC);;
        const QString act = XQConversions::s60DescToQString(
            widgetDescriptor->GetIconUri());
        QCOMPARE(exp, act);    
    }
}

void T_CaWidgetScanner::testCloneWidgetDescriptionL() 
{
    QScopedPointer<CCaWidgetDescription> descriptionA;
    QT_TRAP_THROWING(descriptionA.reset(CCaWidgetDescription::NewL()));
    QScopedPointer<CCaWidgetDescription> descriptionB(
        descriptionA->CloneL());
    
    QVERIFY(descriptionA->Compare(*descriptionB) 
        != static_cast<TInt>(EFalse));
    
    _LIT( KTestDescription, "GetDescription()" );
    
    QT_TRAP_THROWING(
        descriptionA->SetDescriptionL( KTestDescription )
    )
    
    QVERIFY(descriptionA->Compare(*descriptionB) 
        == static_cast<TInt>(EFalse));
    
    QScopedPointer<CCaWidgetDescription> descriptionC(
        descriptionA->CloneL());
    
    QVERIFY(descriptionA->Compare(*descriptionC) 
        != static_cast<TInt>(EFalse));
    
    QVERIFY(descriptionA->GetDescription().Compare( KTestDescription ) == 0);
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TInt T_CaWidgetScanner::AppendMmcIdL(const TDesC& aText)
    {
    //get mmc id
    RBuf mmcId;
    mmcId.CleanupClosePushL();
    mmcId.CreateL(_L("mass_storage"));

    //append mmc id to the entry
    CCaInnerQuery* query = CCaInnerQuery::NewLC();
    CDesC16ArrayFlat* widgetType = new ( ELeave ) CDesC16ArrayFlat(
             KGranularityOne );
    CleanupStack::PushL( widgetType );
    widgetType->AppendL( KCaTypeWidget );
    query->SetEntryTypeNames( widgetType );//transfers ownership to query
    CleanupStack::Pop( widgetType );

    RPointerArray<CCaInnerEntry> entries;
    CleanupResetAndDestroyPushL( entries );
    iStorage->GetEntriesL( query, entries );
    TInt id(0);
    for( TInt i = 0; i < entries.Count(); i++ )
        {
        if(entries[i]->GetText().Compare(aText)==0)
            {
            entries[i]->AddAttributeL(KCaAttrMmcId, mmcId);
            id = entries[i]->GetId();
            iStorage->AddL(entries[i]);
            break;
            }
        }
    CleanupStack::PopAndDestroy( &entries );
    CleanupStack::PopAndDestroy( query );
    CleanupStack::PopAndDestroy( &mmcId );
    return id;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool T_CaWidgetScanner::MmcAttributeSetL(TInt aId)
    {
    TBool result(EFalse);
    CCaInnerQuery* query = CCaInnerQuery::NewLC();
    RArray<TInt> ids;
    CleanupClosePushL(ids);
    ids.AppendL(aId);
    query->SetIdsL(ids);
    CleanupStack::PopAndDestroy(&ids);
    RPointerArray<CCaInnerEntry> entries;
    CleanupResetAndDestroyPushL( entries );
    iStorage->GetEntriesL( query, entries );
    if (entries.Count() == 1)
        {
        TPtrC temp(KNullDesC);
        result = entries[0]->FindAttribute(KCaAttrMmcId, temp);
        }
    CleanupStack::PopAndDestroy( &entries );
    CleanupStack::PopAndDestroy( query );
    
    return result;
    }





QTEST_MAIN(T_CaWidgetScanner);