/*

* Copyright (c) 2004 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 <e32cmn.h>

#include <w32std.h>

#include <apgtask.h>

#include <usif/sif/sifcommon.h>

#include <usif/sif/sif.h>

#include <QScopedPointer>

//  CLASS HEADER

#include "T_casrvAppScaner.h"

//  EXTERNAL INCLUDES

#include <cadef.h>

#include "castoragefactory.h"

#include "castorageproxy.h"

#include "casrvengutils.h"

#include "casrvappscanner.h"

#include "caappscannerhandler.h"

#include "cainnerentry.h"

#include "cainnerquery.h"

#include "caarraycleanup.inl"

#include "casrvmmchistory.h"

#include "t_cainstaller.h"

//  INTERNAL INCLUDES

#include "casrvtestutils.h"

#include "testconsts.h"

#ifdef COVERAGE_MEASUREMENT

const double TIMEOUT_FACTOR = 1.2;

#else

const double TIMEOUT_FACTOR = 1.0;

#endif

template <typename RClass>

struct RClassDeleter

{

    static inline void cleanup(RClass *ptr)

    {

        ptr->Close();

    }

};

typedef RClassDeleter< RPointerArray<CCaInnerEntry> > RInnerEntryArrayDeleter;

typedef QScopedPointer< RPointerArray<CCaInnerEntry>, RInnerEntryArrayDeleter >

    InnerEntryRArrayPointer;

typedef RClassDeleter< RBuf > RBufDeleter;

typedef QScopedPointer< RBuf, RBufDeleter >

    RBufPointer;

using namespace Usif;

const TUid KAppScannerHandlerPluginUid = {0x20026FAF};

void T_casrvAppScaner::initTestCase()

{

    if (iTestUtils == NULL) {

        TRAPD(err, iTestUtils = CTestUtils::NewL());

        QCOMPARE(err, KErrNone);

    }

    QT_TRAP_THROWING(iInstaller = T_CaInstaller::NewL());

    iTestUtils->CopyMmcHistory();

    delete iTestUtils;

    iTestUtils = NULL;

}

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

//

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

//

void T_casrvAppScaner::init()

{

    TRAPD(err,

          iTestUtils = CTestUtils::NewL();

          iTestUtils->CopyDb();

          iStorage = CCaStorageProxy::NewL();

          iSrvEngUtils = CCaSrvEngUtils::NewL();

          iScr =  new Usif::RSoftwareComponentRegistry;

          User::LeaveIfError(iScr->Connect());

         );

    QCOMPARE(err, KErrNone);

}

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

//

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

//

void T_casrvAppScaner::cleanup()

{

    delete iSrvEngUtils;

    iSrvEngUtils = NULL;

    delete iStorage;

    iStorage = NULL;

    delete iTestUtils;

    iTestUtils = NULL;

    iScr->Close();

    delete iScr;

    iScr = NULL;

}

void T_casrvAppScaner::cleanupTestCase()

{    

    Usif::TComponentId wrtComponentId(0);

    TRAP_IGNORE(wrtComponentId = 

        iInstaller->GetComponentIdForAppIdL(KWRTAppId));

    TRAP_IGNORE(iInstaller->UninstallL(wrtComponentId));

    Usif::TComponentId wrtMiniViewComponentId(0); 

    TRAP_IGNORE(wrtMiniViewComponentId = 

        iInstaller->GetComponentIdForAppIdL(KWRTMiniViewAppId));

    TRAP_IGNORE(iInstaller->UninstallL(wrtMiniViewComponentId));

    REComSession::FinalClose();

}

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

//

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

//

void T_casrvAppScaner::Setup_UninstalledL()

{

    RBuf testName;

    testName.CleanupClosePushL();

    testName.CreateL(_L("testname_old"));

    CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();

    innerEntry->SetEntryTypeNameL(KCaTypeApp);

    innerEntry->SetUid(notInstalledUid);

    innerEntry->SetFlags(EVisible);

    innerEntry->SetTextL(testName);

    innerEntry->AddAttributeL(KCaAttrShortName, testName);

    iStorage->AddL(innerEntry);

    CleanupStack::PopAndDestroy(innerEntry);

    CleanupStack::PopAndDestroy(&testName);

}

T_casrvAppScaner::T_casrvAppScaner():

    iTestUtils(NULL),

    iStorage(NULL),

    iSrvEngUtils(NULL),

    iScr(NULL)

{

}

void T_casrvAppScaner::testHandler_LoadPlugin()

{

    TPluginParams params;

    params.engUtils = iSrvEngUtils;

    params.storageProxy = iStorage;

    params.softwareRegistry = iScr;

    bool result(false);

    TRAPD(err,

          CCaSrvPlugin *plug = iTestUtils->LoadPluginL(KAppScannerHandlerPluginUid, params);

          result = plug != NULL;

          delete plug;

         );

    QCOMPARE(err, KErrNone);

    QVERIFY(result);

}

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

//

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

//

void T_casrvAppScaner::testHandler_New()

{

    TPluginParams params;

    params.engUtils = iSrvEngUtils;

    params.storageProxy = iStorage;

    params.softwareRegistry = iScr;

    bool result(false);

    TRAPD(err,

          CCaAppScannerHandler *appScanerHandler = CCaAppScannerHandler::NewL(&params);

          result = appScanerHandler != NULL;

          delete appScanerHandler;

         );

    QCOMPARE(err, KErrNone);

    QVERIFY(result);

}

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

//

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

//

void T_casrvAppScaner::testNew()

{

    bool result(false);

    TRAPD(err,

          Usif::RSoftwareComponentRegistry scr;

          User::LeaveIfError(scr.Connect());

          CCaSrvAppScanner *appScanner = CCaSrvAppScanner::NewL(*iStorage,

                  *iScr,*iSrvEngUtils);

          result = appScanner != NULL;

          scr.Close();

          delete appScanner;

         );

    QCOMPARE(err, KErrNone);

    QVERIFY(result);

}

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

//

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

//

void T_casrvAppScaner::testUninstalled()

{

    bool exists(false);

    bool is_missing(false);

    TRAPD(err,

          Setup_UninstalledL();

          CCaSrvAppScanner *appScanner = CCaSrvAppScanner::NewL(*iStorage,

                  *iScr, *iSrvEngUtils);

          CleanupStack::PushL(appScanner);

          QTest::qWait(7000 * TIMEOUT_FACTOR);

          //visible flag update

          exists = iTestUtils->AppExistsInStorageL(notInstalledUid,

                   iStorage) == TRUE;

          is_missing = (iTestUtils->GetAppFlagsL(notInstalledUid, iStorage)

                  & EMissing) == TRUE;

          CleanupStack::PopAndDestroy(appScanner);

         );

    QCOMPARE(err, KErrNone);

    QVERIFY(exists);

}

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

//

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

//

void T_casrvAppScaner::testInstalled()

{

    bool result(false);

    TRAPD(err,

          CCaSrvAppScanner *appScanner = CCaSrvAppScanner::NewL(*iStorage,

                  *iScr, *iSrvEngUtils);

          CleanupStack::PushL(appScanner);

          QTest::qWait(7000 * TIMEOUT_FACTOR);

          //visible flag update

          result = ((iTestUtils->GetAppFlagsL(systemApp, iStorage)

                     & EVisible) != FALSE);

          CleanupStack::PopAndDestroy(appScanner);

         );

    QCOMPARE(err, KErrNone);

    QVERIFY(result);

}

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

//

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

//

void T_casrvAppScaner::testAddNewApp()

{

    bool result(false);

    TRAPD(err,

          Setup_AddNewAppL();

          CCaSrvAppScanner *appScanner = CCaSrvAppScanner::NewL(*iStorage,

                  *iScr, *iSrvEngUtils);

          CleanupStack::PushL(appScanner);

          QTest::qWait(7000 * TIMEOUT_FACTOR);

          // new app added

          result = ((iTestUtils->GetAppFlagsL(systemApp,iStorage)

                     & EVisible) != FALSE);

          CleanupStack::PopAndDestroy(appScanner);

         );

    QCOMPARE(err, KErrNone);

    QVERIFY(result);

}

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

//

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

//

void T_casrvAppScaner::testNoUpdate()

{

    bool result(false);

    TRAPD(err,

          Setup_NoUpdateL();

          CCaSrvAppScanner *appScanner = CCaSrvAppScanner::NewL(*iStorage,

                  *iScr, *iSrvEngUtils);

          CleanupStack::PushL(appScanner);

          QTest::qWait(7000 * TIMEOUT_FACTOR);

          //no flag update

          result = ((iTestUtils->GetAppFlagsL(systemApp, iStorage)

                     & EVisible) != FALSE);

          CleanupStack::PopAndDestroy(appScanner);

         );

    QCOMPARE(err, KErrNone);

    QVERIFY(result);

}

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

//

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

//

void T_casrvAppScaner::testRemoveMmcApp()

{

    bool exist(false);

    TInt flags(0);

    TRAPD(err,

          Setup_RemoveMmcAppL();

          CCaSrvAppScanner *appScanner = CCaSrvAppScanner::NewL(*iStorage,

                  *iScr, *iSrvEngUtils);

          CleanupStack::PushL(appScanner);

          QTest::qWait(7000 * TIMEOUT_FACTOR);

          //remove mmc attr

          exist = iTestUtils->AppExistsInStorageL(notInstalledUid, iStorage);

          flags = iTestUtils->GetAppFlagsL(notInstalledUid, iStorage);

          CleanupStack::PopAndDestroy(appScanner);

         );

    QCOMPARE(err, KErrNone);

    TBool visible(ETrue);

    visible = flags & EVisible;

    QVERIFY(!visible);

    QVERIFY(exist);

}

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

//

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

//

void T_casrvAppScaner::testRemoveMmcAttr()

{

    bool entryExists(false);

    bool noMmcAttr(false);

    TRAPD(err,

          Setup_RemoveMmcAttrL();

          iInstaller->InstallL(KSapiPackageFileName);

          CCaSrvAppScanner *appScanner = CCaSrvAppScanner::NewL(*iStorage,

                  *iScr, *iSrvEngUtils);

          CleanupStack::PushL(appScanner);

          QTest::qWait(7000 * TIMEOUT_FACTOR);

          //remove mmc attr

          CCaInnerEntry *entry = iTestUtils->GetAppEntryL(installedUid, iStorage);

          entryExists = entry != NULL;

          CleanupStack::PushL(entry);

          RBuf value;

          value.CleanupClosePushL();

          value.CreateL(KCaMassStorage);

    if (entryExists) {

        noMmcAttr = (entry->FindAttribute(KCaAttrMmcId, value) == FALSE);

    }

    CleanupStack::PopAndDestroy(&value);

    CleanupStack::PopAndDestroy(entry);

    CleanupStack::PopAndDestroy(appScanner);

         );

    QCOMPARE(err, KErrNone);

    QVERIFY(entryExists);

    QVERIFY(noMmcAttr);

}

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

//

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

//

void T_casrvAppScaner::testSetCWRTAppL()

{

    RSoftwareInstall sif;

    CleanupClosePushL( sif );

    User::LeaveIfError( sif.Connect() );

    // Install the component

    _LIT16( KSmokeTestUnsigned, "c:\\testing\\data\\t_caappscanner\\installs\\SmokeTestUnsigned.wgt" );

    COpaqueNamedParams* arguments;

    COpaqueNamedParams* results;

    arguments = COpaqueNamedParams::NewLC();

    results = COpaqueNamedParams::NewLC();

    arguments->AddIntL( KSifInParam_InstallSilently, 1 );

    TRequestStatus status;

    sif.Install( KSmokeTestUnsigned, *arguments, *results, status, EFalse );

    User::WaitForRequest( status );

    User::LeaveIfError( status.Int() );

    CleanupStack::PopAndDestroy( results );

    // Install the component

    _LIT16( KAccuWeather, "c:\\testing\\data\\t_caappscanner\\installs\\AccuWeather_W3C.wgt" );

    results = COpaqueNamedParams::NewLC();

    TRequestStatus status2;

    sif.Install( KAccuWeather, *arguments, *results, status2, EFalse );

    User::WaitForRequest( status2 );

    User::LeaveIfError( status2.Int() );

    CleanupStack::PopAndDestroy( results );

    CleanupStack::PopAndDestroy( arguments );

    // Disconnect from the SIF server

    CleanupStack::PopAndDestroy( &sif );

    QScopedPointer<CCaSrvAppScanner> appScanner;

    QT_TRAP_THROWING(appScanner.reset(CCaSrvAppScanner::NewL(

        *iStorage, *iScr, *iSrvEngUtils)));

    QVERIFY(!appScanner.isNull());

    QTest::qWait(7000 * TIMEOUT_FACTOR);

          //remove mmc attr

    QScopedPointer<CCaInnerEntry> entry;

    TInt wrtUid(0);

    TRAP_IGNORE( wrtUid = iTestUtils->FindAppUidL(KWrtAppName, iStorage));

    TRAPD(err, entry.reset(iTestUtils->GetAppEntryL(wrtUid, iStorage)));

    QCOMPARE(err, KErrNone);

    QVERIFY(!entry.isNull());

    QCOMPARE(err, KErrNone);

    QTest::qWait(7000 * TIMEOUT_FACTOR);

    TInt wrtMiniViewUid(0);

    TRAP_IGNORE( wrtMiniViewUid = 

        iTestUtils->FindAppUidL( KWrtMiniViewAppName, iStorage ));

    TRAP(err, entry.reset(iTestUtils->GetAppEntryL(wrtMiniViewUid, iStorage)));

    QCOMPARE(err, KErrNone);

    QVERIFY(!entry.isNull());

    bool exists(false);

    bool match(false);

    TRAP(err,

    		RBuf value;

			value.CleanupClosePushL();

			value.CreateL(KCaMaxAttrLenght);

			exists = (entry->FindAttribute(KCaAttrAppWidgetUri, value) != 0);

			match = (value == KCaAttrAppWidgetUriCWRTValue);

			CleanupStack::PopAndDestroy(&value);

    );

    QCOMPARE(err, KErrNone);

    QVERIFY(exists);

    QVERIFY(match);

    exists = false;

    TRAP(err,

    		RBuf value;

			value.CleanupClosePushL();

			value.CreateL(KCaMaxAttrLenght);

			exists = (entry->FindAttribute(KCaAttrAppWidgetParamWebAppId, value) != 0);

			CleanupStack::PopAndDestroy(&value);

    );

    QCOMPARE(err, KErrNone);

    QVERIFY(exists); 

}

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

//

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

//

void T_casrvAppScaner::testRemoveMissingFlag()

{

    bool result(false);

    TRAPD(err,

          Setup_RemoveMissingFlagL();

          CCaSrvAppScanner *appScanner = CCaSrvAppScanner::NewL(*iStorage,

                  *iScr, *iSrvEngUtils);

          CleanupStack::PushL(appScanner);

          QTest::qWait(7000 * TIMEOUT_FACTOR);

          //remove missing flag

          result = (iTestUtils->AppExistsInStorageL(notInstalledUid,

                    iStorage) != FALSE);

          CleanupStack::PopAndDestroy(appScanner);

         );

    QCOMPARE(err, KErrNone);

    QVERIFY(result);

}

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

//

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

//

void T_casrvAppScaner::testRemoveMissingFlag01()

{

    bool exists(false);

    bool noMissingFlag(false);

    TRAPD(err,

          Setup_RemoveMissingFlag01L();

          iInstaller->InstallL(KSapiPackageFileName);

          CCaSrvAppScanner *appScanner = CCaSrvAppScanner::NewL(*iStorage,

                  *iScr, *iSrvEngUtils);

          CleanupStack::PushL(appScanner);

          QTest::qWait(7000 * TIMEOUT_FACTOR);

          //remove missing flag

          exists = ((iTestUtils->GetAppFlagsL(

                         installedUid, iStorage) & EVisible) != FALSE);

          noMissingFlag =((iTestUtils->GetAppFlagsL(

                               installedUid, iStorage) & EMissing) == FALSE);

          CleanupStack::PopAndDestroy(appScanner);

         );