/*

* 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 <w32std.h>

#include <apgtask.h>

#include <usif/sif/sifcommon.h>

#include <usif/sif/sif.h>

//  CLASS HEADER

#include "T_caUsifScaner.h"

//  EXTERNAL INCLUDES

#include <cadef.h>

#include "castoragefactory.h"

#include "castorageproxy.h"

#include "casrvengutils.h"

#include "causifscanner.h"

#include "causifscanner.hrh"

#include "cainnerentry.h"

#include "cainnerquery.h"

#include "caarraycleanup.inl"

#include "casrvmmchistory.h"

//  INTERNAL INCLUDES

#include "casrvtestutils.h"

#include "testconsts.h"

#include "t_cainstaller.h"

#ifdef COVERAGE_MEASUREMENT

const unsigned int TIMEOUT_FACTOR = 2;

#else

const unsigned int TIMEOUT_FACTOR = 1;

#endif

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

//

T_caUsifScaner::T_caUsifScaner():

    iTestUtils(NULL),

    iStorage(NULL),

    iSrvEngUtils(NULL)

{

}

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

//

void T_caUsifScaner::initTestCase()

{

    if (iTestUtils == NULL) {

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

        QCOMPARE(err, KErrNone);

    }

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

    TRAP_IGNORE(iInstaller->InstallL(KSapiPackageFileName));

    QTest::qWait(10000);

    delete iTestUtils;

    iTestUtils = NULL;

}

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

//

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

//

void T_caUsifScaner::init()

{

    TRAPD(err,

          iTestUtils = CTestUtils::NewL();

          iTestUtils->CopyDb();

          iStorage = CCaStorageProxy::NewL();

          iSrvEngUtils = CCaSrvEngUtils::NewL();

          iScr = new Usif::RSoftwareComponentRegistry;          

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

          iPluginParams.storageProxy = iStorage;

          iPluginParams.engUtils = iSrvEngUtils;

          iPluginParams.softwareRegistry = iScr;

         );

    QCOMPARE(err, KErrNone);

}

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

//

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

//

void T_caUsifScaner::cleanup()

{

    iPluginParams.storageProxy = NULL;

    iPluginParams.engUtils = NULL;

    iScr->Close();

    iPluginParams.softwareRegistry = NULL;

    delete iSrvEngUtils;

    iSrvEngUtils = NULL;

    delete iStorage;

    iStorage = NULL;

    delete iTestUtils;

    iTestUtils = NULL;

    delete iScr;

    iScr = NULL;

}

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

//

void T_caUsifScaner::cleanupTestCase()

{

    TRAPD(err, iInstaller->UninstallL(KSapiAppFileName));

    QCOMPARE(err, KErrNone);

    delete iTestUtils;

    iTestUtils = NULL;

    delete iInstaller;

    REComSession::FinalClose();

}

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

//

void T_caUsifScaner::testNew()

{

    bool result(false);

    TRAPD(err,

          CCaUsifScanner *usifScanner = CCaUsifScanner::NewL(&iPluginParams);

          result = usifScanner != NULL;

          QTest::qWait(5000);

          delete usifScanner;

         );

    QCOMPARE(err, KErrNone);

    QVERIFY(result);

}

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

//

void T_caUsifScaner::testLoadPlugin()

{

    bool result(false);

    TRAPD(err, CCaSrvPlugin *plug = iTestUtils->LoadPluginL(

            TUid::Uid(KCaSrvUsifScannerPlugin), iPluginParams);

          result = plug != NULL;

          QTest::qWait(5000);

          delete plug;

         );

    QCOMPARE(err, KErrNone);

    QVERIFY(result);

}

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

//

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

//

void T_caUsifScaner::testInstalled()

{

    bool flags(false);

    TRAPD(err,

        CCaUsifScanner *usifScaner = CCaUsifScanner::NewL(&iPluginParams);

        CleanupStack::PushL(usifScaner);

        QTest::qWait(5000);

        //visible flag update

        flags = ((iTestUtils->GetPackageFlagsL(KSapiApp, iStorage)

                & (EVisible | ERemovable) ) != FALSE);

          CleanupStack::PopAndDestroy(usifScaner);

         );

    QCOMPARE(err, KErrNone);

    QVERIFY(flags);

}

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

//

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

//

void T_caUsifScaner::testAddNewApp()

{

    bool result(false);

    TRAPD(err,

          Setup_AddNewAppL();

          CCaUsifScanner *usifScaner = CCaUsifScanner::NewL(&iPluginParams);

          CleanupStack::PushL(usifScaner);

          QTest::qWait(5000);

          // new app added

          result = ((iTestUtils->GetPackageFlagsL(KSapiApp,iStorage)

                     & (EVisible | ERemovable)) != FALSE);

          CleanupStack::PopAndDestroy(usifScaner);

         );

    QCOMPARE(err, KErrNone);

    QVERIFY(result);

}

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

//

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

//

void T_caUsifScaner::testAddRemovable()

{

    bool result(false);

    TRAPD(err,

        Setup_AddRemovableL();

        CCaUsifScanner *usifScaner = CCaUsifScanner::NewL(&iPluginParams);

        CleanupStack::PushL(usifScaner);

        QTest::qWait(5000 * TIMEOUT_FACTOR);

        //add removable flag to installed app

        result = ((iTestUtils->GetPackageFlagsL(KSapiApp, iStorage)

                & (ERemovable | EVisible)) != FALSE);

        CleanupStack::PopAndDestroy(usifScaner);

    );

    QCOMPARE(err, KErrNone);

    QVERIFY(result);

}

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

//

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

//

void T_caUsifScaner::testInstallNotifier()

{

    bool existsAfterInstall(false);

    TRAPD(err,

        CCaUsifScanner *usifScanner = CCaUsifScanner::NewL(&iPluginParams);

        CleanupStack::PushL(usifScanner);

        iInstaller->InstallL(KSapiPackageFileName);

        QTest::qWait(20000 * TIMEOUT_FACTOR);

        existsAfterInstall = iTestUtils->GetPackageFlagsL(KSapiApp, iStorage);

        CleanupStack::PopAndDestroy(usifScanner);

        );

    QCOMPARE(err, KErrNone);

    QVERIFY(existsAfterInstall);

}

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

//

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

//

void T_caUsifScaner::Setup_AddNewAppL()

{

    TBool exists = iTestUtils->AppExistsInStorageL(installedUid, iStorage);

    if (exists) {

        iTestUtils->RemoveAppL(installedUid, iStorage);

        exists = iTestUtils->AppExistsInStorageL(installedUid, iStorage);

        if (exists) {

            User::Leave(KErrNotReady);

        }

    }

}

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

//

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

//

void T_caUsifScaner::Setup_AddRemovableL()

{

    RBuf testName;

    testName.CleanupClosePushL();

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

    CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();

    innerEntry->SetEntryTypeNameL(KCaTypeApp);

    innerEntry->SetUid(installedUid);

    innerEntry->SetFlags(innerEntry->GetFlags() & ~ERemovable | EVisible);

    innerEntry->SetTextL(testName);

    innerEntry->AddAttributeL(KCaAttrComponentId, _L("10"));

    iStorage->AddL(innerEntry);

    CleanupStack::PopAndDestroy(innerEntry);

    CleanupStack::PopAndDestroy(&testName);

}

QTEST_MAIN(T_caUsifScaner);

//  END OF FILE