1 /*

     2 * Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 #include <e32cmn.h>

    18 #include <w32std.h>

    19 #include <apgtask.h>

    20 #include <usif/sif/sifcommon.h>

    21 #include <usif/sif/sif.h>

    22 

    23 #include <QScopedPointer>

    24 //  CLASS HEADER

    25 #include "T_casrvAppScaner.h"

    26 

    27 //  EXTERNAL INCLUDES

    28 

    29 #include <cadef.h>

    30 

    31 #include "castoragefactory.h"

    32 #include "castorageproxy.h"

    33 #include "casrvengutils.h"

    34 #include "casrvappscanner.h"

    35 #include "caappscannerhandler.h"

    36 #include "cainnerentry.h"

    37 #include "cainnerquery.h"

    38 #include "caarraycleanup.inl"

    39 #include "casrvmmchistory.h"

    40 

    41 #include "t_cainstaller.h"

    42 //  INTERNAL INCLUDES

    43 #include "casrvtestutils.h"

    44 #include "testconsts.h"

    45 

    46 #ifdef COVERAGE_MEASUREMENT

    47 const double TIMEOUT_FACTOR = 1.2;

    48 #else

    49 const double TIMEOUT_FACTOR = 1.0;

    50 #endif

    51 

    52 template <typename RClass>

    53 struct RClassDeleter

    54 {

    55     static inline void cleanup(RClass *ptr)

    56     {

    57         ptr->Close();

    58     }

    59 };

    60 

    61 typedef RClassDeleter< RPointerArray<CCaInnerEntry> > RInnerEntryArrayDeleter;

    62 typedef QScopedPointer< RPointerArray<CCaInnerEntry>, RInnerEntryArrayDeleter >

    63     InnerEntryRArrayPointer;

    64 

    65 typedef RClassDeleter< RBuf > RBufDeleter;

    66 typedef QScopedPointer< RBuf, RBufDeleter >

    67     RBufPointer;

    68 

    69 using namespace Usif;

    70 

    71 const TUid KAppScannerHandlerPluginUid = {0x20026FAF};

    72 

    73 void T_casrvAppScaner::initTestCase()

    74 {

    75 

    76     if (iTestUtils == NULL) {

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

    78         QCOMPARE(err, KErrNone);

    79     }

    80 

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

    82 

    83     iTestUtils->CopyMmcHistory();

    84 

    85     delete iTestUtils;

    86     iTestUtils = NULL;

    87 }

    88 

    89 // ---------------------------------------------------------------------------

    90 //

    91 // ---------------------------------------------------------------------------

    92 //

    93 void T_casrvAppScaner::init()

    94 {

    95     TRAPD(err,

    96           iTestUtils = CTestUtils::NewL();

    97           iTestUtils->CopyDb();

    98 

    99           iStorage = CCaStorageProxy::NewL();

   100           iSrvEngUtils = CCaSrvEngUtils::NewL();

   101           iScr =  new Usif::RSoftwareComponentRegistry;

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

   103          );

   104     QCOMPARE(err, KErrNone);

   105 }

   106 

   107 // ---------------------------------------------------------------------------

   108 //

   109 // ---------------------------------------------------------------------------

   110 //

   111 void T_casrvAppScaner::cleanup()

   112 {

   113     delete iSrvEngUtils;

   114     iSrvEngUtils = NULL;

   115     delete iStorage;

   116     iStorage = NULL;

   117     delete iTestUtils;

   118     iTestUtils = NULL;

   119     iScr->Close();

   120     delete iScr;

   121     iScr = NULL;

   122 }

   123 

   124 void T_casrvAppScaner::cleanupTestCase()

   125 {    

   126     Usif::TComponentId wrtComponentId(0);

   127     

   128     TRAP_IGNORE(wrtComponentId = 

   129         iInstaller->GetComponentIdForAppIdL(KWRTAppId));

   130     TRAP_IGNORE(iInstaller->UninstallL(wrtComponentId));

   131     

   132     Usif::TComponentId wrtMiniViewComponentId(0); 

   133     TRAP_IGNORE(wrtMiniViewComponentId = 

   134         iInstaller->GetComponentIdForAppIdL(KWRTMiniViewAppId));

   135     TRAP_IGNORE(iInstaller->UninstallL(wrtMiniViewComponentId));

   136     

   137     REComSession::FinalClose();

   138 }

   139 

   140 // ---------------------------------------------------------------------------

   141 //

   142 // ---------------------------------------------------------------------------

   143 //

   144 void T_casrvAppScaner::Setup_UninstalledL()

   145 {

   146     RBuf testName;

   147     testName.CleanupClosePushL();

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

   149     CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();

   150     innerEntry->SetEntryTypeNameL(KCaTypeApp);

   151     innerEntry->SetUid(notInstalledUid);

   152     innerEntry->SetFlags(EVisible);

   153     innerEntry->SetTextL(testName);

   154     innerEntry->AddAttributeL(KCaAttrShortName, testName);

   155 

   156     iStorage->AddL(innerEntry);

   157     CleanupStack::PopAndDestroy(innerEntry);

   158     CleanupStack::PopAndDestroy(&testName);

   159 }

   160 

   161 T_casrvAppScaner::T_casrvAppScaner():

   162     iTestUtils(NULL),

   163     iStorage(NULL),

   164     iSrvEngUtils(NULL),

   165     iScr(NULL)

   166 {

   167 

   168 }

   169 

   170 void T_casrvAppScaner::testHandler_LoadPlugin()

   171 {

   172     TPluginParams params;

   173     params.engUtils = iSrvEngUtils;

   174     params.storageProxy = iStorage;

   175     params.softwareRegistry = iScr;

   176 

   177     bool result(false);

   178 

   179     TRAPD(err,

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

   181           result = plug != NULL;

   182           delete plug;

   183          );

   184     QCOMPARE(err, KErrNone);

   185     QVERIFY(result);

   186 }

   187 

   188 // ---------------------------------------------------------------------------

   189 //

   190 // ---------------------------------------------------------------------------

   191 //

   192 void T_casrvAppScaner::testHandler_New()

   193 {

   194     TPluginParams params;

   195     params.engUtils = iSrvEngUtils;

   196     params.storageProxy = iStorage;

   197     params.softwareRegistry = iScr;

   198 

   199     bool result(false);

   200     TRAPD(err,

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

   202           result = appScanerHandler != NULL;

   203           delete appScanerHandler;

   204          );

   205     QCOMPARE(err, KErrNone);

   206     QVERIFY(result);

   207 }

   208 

   209 // ---------------------------------------------------------------------------

   210 //

   211 // ---------------------------------------------------------------------------

   212 //

   213 void T_casrvAppScaner::testNew()

   214 {

   215     bool result(false);

   216     TRAPD(err,

   217           Usif::RSoftwareComponentRegistry scr;

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

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

   220                   *iScr,*iSrvEngUtils);

   221           result = appScanner != NULL;

   222           scr.Close();

   223           delete appScanner;

   224          );

   225     QCOMPARE(err, KErrNone);

   226     QVERIFY(result);

   227 }

   228 

   229 // ---------------------------------------------------------------------------

   230 //

   231 // ---------------------------------------------------------------------------

   232 //

   233 void T_casrvAppScaner::testUninstalled()

   234 {

   235     bool exists(false);

   236     bool is_missing(false);

   237     TRAPD(err,

   238           Setup_UninstalledL();

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

   240                   *iScr, *iSrvEngUtils);

   241           CleanupStack::PushL(appScanner);

   242           QTest::qWait(7000 * TIMEOUT_FACTOR);

   243           //visible flag update

   244           exists = iTestUtils->AppExistsInStorageL(notInstalledUid,

   245                    iStorage) == TRUE;

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

   247                   & EMissing) == TRUE;

   248 

   249           CleanupStack::PopAndDestroy(appScanner);

   250          );

   251     QCOMPARE(err, KErrNone);

   252     QVERIFY(exists);

   253 }

   254 

   255 // ---------------------------------------------------------------------------

   256 //

   257 // ---------------------------------------------------------------------------

   258 //

   259 void T_casrvAppScaner::testInstalled()

   260 {

   261     bool result(false);

   262     TRAPD(err,

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

   264                   *iScr, *iSrvEngUtils);

   265           CleanupStack::PushL(appScanner);

   266           QTest::qWait(7000 * TIMEOUT_FACTOR);

   267           //visible flag update

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

   269                      & EVisible) != FALSE);

   270 

   271           CleanupStack::PopAndDestroy(appScanner);

   272          );

   273     QCOMPARE(err, KErrNone);

   274     QVERIFY(result);

   275 }

   276 // ---------------------------------------------------------------------------

   277 //

   278 // ---------------------------------------------------------------------------

   279 //

   280 void T_casrvAppScaner::testAddNewApp()

   281 {

   282     bool result(false);

   283     TRAPD(err,

   284           Setup_AddNewAppL();

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

   286                   *iScr, *iSrvEngUtils);

   287           CleanupStack::PushL(appScanner);

   288           QTest::qWait(7000 * TIMEOUT_FACTOR);

   289           // new app added

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

   291                      & EVisible) != FALSE);

   292 

   293           CleanupStack::PopAndDestroy(appScanner);

   294          );

   295     QCOMPARE(err, KErrNone);

   296     QVERIFY(result);

   297 }

   298 

   299 // ---------------------------------------------------------------------------

   300 //

   301 // ---------------------------------------------------------------------------

   302 //

   303 void T_casrvAppScaner::testNoUpdate()

   304 {

   305     bool result(false);

   306     TRAPD(err,

   307           Setup_NoUpdateL();

   308 

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

   310                   *iScr, *iSrvEngUtils);

   311           CleanupStack::PushL(appScanner);

   312           QTest::qWait(7000 * TIMEOUT_FACTOR);

   313           //no flag update

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

   315                      & EVisible) != FALSE);

   316 

   317           CleanupStack::PopAndDestroy(appScanner);

   318          );

   319     QCOMPARE(err, KErrNone);

   320     QVERIFY(result);

   321 }

   322 

   323 // ---------------------------------------------------------------------------

   324 //

   325 // ---------------------------------------------------------------------------

   326 //

   327 void T_casrvAppScaner::testRemoveMmcApp()

   328 {

   329     bool exist(false);

   330     TInt flags(0);

   331     TRAPD(err,

   332           Setup_RemoveMmcAppL();

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

   334                   *iScr, *iSrvEngUtils);

   335           CleanupStack::PushL(appScanner);

   336           QTest::qWait(7000 * TIMEOUT_FACTOR);

   337           //remove mmc attr

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

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

   340           CleanupStack::PopAndDestroy(appScanner);

   341          );

   342     QCOMPARE(err, KErrNone);

   343     TBool visible(ETrue);

   344     visible = flags & EVisible;

   345     QVERIFY(!visible);

   346     QVERIFY(exist);

   347 }

   348 

   349 // ---------------------------------------------------------------------------

   350 //

   351 // ---------------------------------------------------------------------------

   352 //

   353 

   354 void T_casrvAppScaner::testRemoveMmcAttr()

   355 {

   356     bool entryExists(false);

   357     bool noMmcAttr(false);

   358     TRAPD(err,

   359           Setup_RemoveMmcAttrL();

   360           iInstaller->InstallL(KSapiPackageFileName);

   361 

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

   363                   *iScr, *iSrvEngUtils);

   364           CleanupStack::PushL(appScanner);

   365           QTest::qWait(7000 * TIMEOUT_FACTOR);

   366           //remove mmc attr

   367 

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

   369           entryExists = entry != NULL;

   370 

   371           CleanupStack::PushL(entry);

   372           RBuf value;

   373           value.CleanupClosePushL();

   374           value.CreateL(KCaMassStorage);

   375     if (entryExists) {

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

   377     }

   378     CleanupStack::PopAndDestroy(&value);

   379     CleanupStack::PopAndDestroy(entry);

   380     CleanupStack::PopAndDestroy(appScanner);

   381          );

   382     QCOMPARE(err, KErrNone);

   383     QVERIFY(entryExists);

   384     QVERIFY(noMmcAttr);

   385 }

   386 

   387 

   388 // ---------------------------------------------------------------------------

   389 //

   390 // ---------------------------------------------------------------------------

   391 //

   392 

   393 void T_casrvAppScaner::testSetCWRTAppL()

   394 {

   395     RSoftwareInstall sif;

   396     CleanupClosePushL( sif );

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

   398 

   399     // Install the component

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

   401     COpaqueNamedParams* arguments;

   402     COpaqueNamedParams* results;

   403     arguments = COpaqueNamedParams::NewLC();

   404     results = COpaqueNamedParams::NewLC();

   405     arguments->AddIntL( KSifInParam_InstallSilently, 1 );

   406     TRequestStatus status;

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

   408     User::WaitForRequest( status );

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

   410     CleanupStack::PopAndDestroy( results );

   411     

   412     // Install the component

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

   414     results = COpaqueNamedParams::NewLC();

   415     TRequestStatus status2;

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

   417     User::WaitForRequest( status2 );

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

   419     CleanupStack::PopAndDestroy( results );

   420     CleanupStack::PopAndDestroy( arguments );

   421 

   422     // Disconnect from the SIF server

   423     CleanupStack::PopAndDestroy( &sif );

   424 

   425     

   426     QScopedPointer<CCaSrvAppScanner> appScanner;

   427     QT_TRAP_THROWING(appScanner.reset(CCaSrvAppScanner::NewL(

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

   429     

   430     QVERIFY(!appScanner.isNull());

   431     

   432     QTest::qWait(7000 * TIMEOUT_FACTOR);

   433           //remove mmc attr

   434 

   435     QScopedPointer<CCaInnerEntry> entry;

   436 

   437     TInt wrtUid(0);

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

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

   440     QCOMPARE(err, KErrNone);

   441     QVERIFY(!entry.isNull());

   442     

   443     QCOMPARE(err, KErrNone);

   444 

   445     QTest::qWait(7000 * TIMEOUT_FACTOR);

   446 

   447     TInt wrtMiniViewUid(0);

   448 

   449     TRAP_IGNORE( wrtMiniViewUid = 

   450         iTestUtils->FindAppUidL( KWrtMiniViewAppName, iStorage ));

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

   452     QCOMPARE(err, KErrNone);

   453     QVERIFY(!entry.isNull());

   454 

   455     bool exists(false);

   456     bool match(false);

   457     TRAP(err,

   458     		RBuf value;

   459 			value.CleanupClosePushL();

   460 			value.CreateL(KCaMaxAttrLenght);

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

   462 			match = (value == KCaAttrAppWidgetUriCWRTValue);

   463 			CleanupStack::PopAndDestroy(&value);

   464     );

   465     QCOMPARE(err, KErrNone);

   466     QVERIFY(exists);

   467     QVERIFY(match);

   468     

   469     exists = false;

   470     TRAP(err,

   471     		RBuf value;

   472 			value.CleanupClosePushL();

   473 			value.CreateL(KCaMaxAttrLenght);

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

   475 			CleanupStack::PopAndDestroy(&value);

   476     );

   477     QCOMPARE(err, KErrNone);

   478     QVERIFY(exists); 

   479 

   480 }

   481 

   482 // ---------------------------------------------------------------------------

   483 //

   484 // ---------------------------------------------------------------------------

   485 //

   486 void T_casrvAppScaner::testRemoveMissingFlag()

   487 {

   488     bool result(false);

   489     TRAPD(err,

   490           Setup_RemoveMissingFlagL();

   491 

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

   493                   *iScr, *iSrvEngUtils);

   494           CleanupStack::PushL(appScanner);

   495           QTest::qWait(7000 * TIMEOUT_FACTOR);

   496           //remove missing flag

   497           result = (iTestUtils->AppExistsInStorageL(notInstalledUid,

   498                     iStorage) != FALSE);

   499 

   500           CleanupStack::PopAndDestroy(appScanner);

   501          );

   502     QCOMPARE(err, KErrNone);

   503     QVERIFY(result);

   504 }

   505 

   506 // ---------------------------------------------------------------------------

   507 //

   508 // ---------------------------------------------------------------------------

   509 //

   510 

   511 void T_casrvAppScaner::testRemoveMissingFlag01()

   512 {

   513     bool exists(false);

   514     bool noMissingFlag(false);

   515     TRAPD(err,

   516           Setup_RemoveMissingFlag01L();

   517           iInstaller->InstallL(KSapiPackageFileName);

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

   519                   *iScr, *iSrvEngUtils);

   520           CleanupStack::PushL(appScanner);

   521           QTest::qWait(7000 * TIMEOUT_FACTOR);

   522           //remove missing flag

   523           exists = ((iTestUtils->GetAppFlagsL(

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

   525           noMissingFlag =((iTestUtils->GetAppFlagsL(

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

   527 

   528           CleanupStack::PopAndDestroy(appScanner);

   529          );

   530     QCOMPARE(err, KErrNone);

   531     QVERIFY(exists);

   532     QVERIFY(noMissingFlag);

   533 }

   534 

   535 

   536 // ---------------------------------------------------------------------------

   537 //

   538 // ---------------------------------------------------------------------------

   539 //

   540 void T_casrvAppScaner::testAddMissingFlag()

   541 {

   542     bool result(false);

   543     TRAPD(err,

   544           Setup_AddMissingFlagL();

   545           QTest::qWait(1000);

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

   547                   *iScr, *iSrvEngUtils);

   548           CleanupStack::PushL(appScanner);

   549           QTest::qWait(7000 * TIMEOUT_FACTOR);

   550           //Add missing flag

   551           result = (iTestUtils->GetAppFlagsL(notInstalledUid, iStorage)

   552                     & EMissing) != FALSE;

   553 

   554           CleanupStack::PopAndDestroy(appScanner);

   555          );

   556     QCOMPARE(err, KErrNone);

   557     QVERIFY(result);

   558 }

   559 

   560 // ---------------------------------------------------------------------------

   561 //

   562 // ---------------------------------------------------------------------------

   563 //

   564 void T_casrvAppScaner::testSatApp()

   565 {

   566     bool visibleFlag(false);

   567     bool missingFlag(false);

   568     TRAPD(err,

   569           Setup_SatAppL();

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

   571                   *iScr, *iSrvEngUtils);

   572           CleanupStack::PushL(appScanner);

   573           QTest::qWait(7000 * TIMEOUT_FACTOR);

   574           //sat app should not be updated by app scanner

   575           visibleFlag = ((iTestUtils->GetAppFlagsL(

   576                               KSatUid.iUid, iStorage) & EVisible) != FALSE);

   577           missingFlag = ((iTestUtils->GetAppFlagsL(

   578                               KSatUid.iUid, iStorage) & EMissing) != FALSE);

   579 

   580           CleanupStack::PopAndDestroy(appScanner);

   581          );

   582     QCOMPARE(err, KErrNone);

   583     QVERIFY(visibleFlag);

   584     QVERIFY(missingFlag);

   585 }

   586 

   587 // ---------------------------------------------------------------------------

   588 //

   589 // ---------------------------------------------------------------------------

   590 //

   591 void T_casrvAppScaner::testHsApp()

   592 {

   593     bool visibleFlag;

   594     TRAPD(err,

   595           Setup_HsAppL();

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

   597                   *iScr, *iSrvEngUtils);

   598           CleanupStack::PushL(appScanner);

   599           QTest::qWait(7000 * TIMEOUT_FACTOR);

   600           //HS app should not be updated by app scanner

   601           visibleFlag = ((iTestUtils->GetAppFlagsL(

   602                               KHsAppUid.iUid, iStorage) & EVisible) != FALSE);

   603           CleanupStack::PopAndDestroy(appScanner);

   604          );

   605 

   606     QCOMPARE(err, KErrNone);

   607     QVERIFY(!visibleFlag);

   608 }

   609 

   610 // ---------------------------------------------------------------------------

   611 //

   612 // ---------------------------------------------------------------------------

   613 //

   614 

   615 void T_casrvAppScaner::testAddRemovable()

   616 {

   617     bool result(false);

   618     TRAPD(err,

   619           Setup_AddRemovableL();

   620           iInstaller->InstallL(KSapiPackageFileName);

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

   622                   *iScr, *iSrvEngUtils);

   623           CleanupStack::PushL(appScanner);

   624           QTest::qWait(7000 * TIMEOUT_FACTOR);

   625           //add removable flag to not visible app

   626           result = ((iTestUtils->GetAppFlagsL(

   627                          installedUid, iStorage) & ERemovable) != FALSE);

   628 

   629           CleanupStack::PopAndDestroy(appScanner);

   630          );

   631     QCOMPARE(err, KErrNone);

   632     QVERIFY(result);

   633 }

   634 

   635 // ---------------------------------------------------------------------------

   636 //

   637 // ---------------------------------------------------------------------------

   638 //

   639 void T_casrvAppScaner::testRemoveRemovable()

   640 {

   641     bool result(false);

   642     TRAPD(err,

   643           Setup_RemoveRemovableL();

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

   645                   *iScr, *iSrvEngUtils);

   646           CleanupStack::PushL(appScanner);

   647           QTest::qWait(7000);

   648           //remove removable flag to not visible app

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

   650                      & ERemovable) == FALSE);

   651 

   652           CleanupStack::PopAndDestroy(appScanner);

   653          );

   654     QCOMPARE(err, KErrNone);

   655     QVERIFY(result);

   656 }

   657 

   658 // ---------------------------------------------------------------------------

   659 //

   660 // ---------------------------------------------------------------------------

   661 //

   662 void T_casrvAppScaner::testRunError()

   663 {

   664     bool result(false);

   665     TRAPD(err,

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

   667                   *iScr, *iSrvEngUtils);

   668           CleanupStack::PushL(appScanner);

   669           result = (!appScanner->RunError(1));

   670           CleanupStack::PopAndDestroy(appScanner);

   671          );

   672     QCOMPARE(err, KErrNone);

   673     QVERIFY(result);

   674 }

   675 

   676 // ---------------------------------------------------------------------------

   677 //

   678 // ---------------------------------------------------------------------------

   679 //

   680 

   681 void T_casrvAppScaner::testInstallNotifier()

   682 {

   683     bool existsBeforeUninstall(false);

   684     bool existsAfterUninstall(false);

   685 

   686     QScopedPointer<CCaSrvAppScanner> appScanner;

   687     QT_TRAP_THROWING(appScanner.reset(CCaSrvAppScanner::NewL(*iStorage,

   688             *iScr, *iSrvEngUtils)))

   689 

   690     //test

   691     TInt err(KErrNone);

   692     TRAP(err, iInstaller->InstallL(KSapiPackageFileName))

   693     QCOMPARE(err, KErrNone);

   694     QTest::qWait(7000 * TIMEOUT_FACTOR);

   695 

   696     TComponentId componentId(0);

   697     TRAP(err, componentId = iInstaller->GetComponentIdL(installedUid));

   698     QCOMPARE(err, KErrNone);

   699     

   700     TRAP(err, existsBeforeUninstall = (iTestUtils->ComponentExistsInStorageL(

   701                                  componentId, iStorage) != FALSE));

   702     QCOMPARE(err, KErrNone);

   703     

   704     TRAP(err, iInstaller->UninstallL(componentId))

   705     QCOMPARE(err, KErrNone);

   706     

   707     QTest::qWait(7000 * TIMEOUT_FACTOR);

   708 

   709     TRAP(err, existsAfterUninstall = (iTestUtils->ComponentExistsInStorageL(

   710                                 componentId, iStorage) != FALSE))

   711     QCOMPARE(err, KErrNone);

   712 

   713     QVERIFY(existsBeforeUninstall);

   714     QVERIFY(existsAfterUninstall);

   715 }

   716 

   717 // ---------------------------------------------------------------------------

   718 //

   719 // ---------------------------------------------------------------------------

   720 //

   721 void T_casrvAppScaner::testDownloadCollectionAdd()

   722 {

   723     cleanup();

   724     init();

   725     TInt countAfterInstall(0);

   726     TInt countBeforeInstall(0);

   727     bool existsAfterInstall(false);

   728     QScopedPointer<CCaSrvAppScanner> appScanner;

   729     QT_TRAP_THROWING(appScanner.reset(CCaSrvAppScanner::NewL(*iStorage,

   730             *iScr, *iSrvEngUtils)))

   731 

   732     // ensure the application is not installed

   733     TComponentId unComponentId;

   734 

   735     TRAP_IGNORE(unComponentId = iInstaller->GetComponentIdL(installedUid))

   736 

   737     if( unComponentId > 0 )

   738         {

   739         TRAP_IGNORE(iInstaller->UninstallL(unComponentId));

   740         }

   741 

   742     RPointerArray<CCaInnerEntry> array;

   743     InnerEntryRArrayPointer resultArray(&array);

   744 

   745     QScopedPointer<CDesC16ArrayFlat> appType;

   746 

   747     QT_TRAP_THROWING(appType.reset(new(ELeave) CDesC16ArrayFlat(1)));

   748 

   749     TRAPD(error, appType->AppendL(KCaTypeApp));

   750     QCOMPARE(error, KErrNone);

   751 

   752     QScopedPointer<CCaInnerQuery> query;

   753 

   754     TRAP(error, query.reset(CCaInnerQuery::NewL()));

   755     QCOMPARE(error, KErrNone);

   756 

   757     query->SetEntryTypeNames(appType.take());

   758 

   759     QTest::qWait(20000 * TIMEOUT_FACTOR);

   760 

   761     TInt dcID(0);

   762 

   763     TRAP(error, dcID = appScanner->GetCollectionDownloadIdL());

   764     QCOMPARE(error, KErrNone);

   765 

   766     query->SetParentId(dcID);

   767     query->SetFlagsOn(EVisible);

   768     query->SetFlagsOff(EMissing);

   769 

   770     TRAP(error, iStorage->GetEntriesL(query.data(), *resultArray));

   771     QCOMPARE(error, KErrNone);

   772     countBeforeInstall =  resultArray->Count();

   773 

   774     TRAP(error, iInstaller->InstallL(KSapiPackageFileName));

   775     QCOMPARE(error, KErrNone);

   776 

   777     QTest::qWait(20000 * TIMEOUT_FACTOR);

   778 

   779     TComponentId componentId(0);

   780     TRAP(error, componentId = iInstaller->GetComponentIdL(installedUid));

   781     QCOMPARE(error, KErrNone);

   782 

   783     TRAP(error, iStorage->GetEntriesL(query.data(), *resultArray));

   784     QCOMPARE(error, KErrNone);

   785     countAfterInstall =  resultArray->Count();

   786 

   787     existsAfterInstall = (iTestUtils->ComponentExistsInStorageL(

   788                               componentId, iStorage));

   789 

   790     TRAP(error, iInstaller->UninstallL(componentId));

   791     QCOMPARE(error, KErrNone);

   792 

   793     QVERIFY(countAfterInstall == countBeforeInstall + 1);

   794     QVERIFY(existsAfterInstall);

   795 }

   796 

   797 // ---------------------------------------------------------------------------

   798 //

   799 // ---------------------------------------------------------------------------

   800 //

   801 void T_casrvAppScaner::testDownloadCollectionUpdate()

   802 {

   803     TInt countAfterInstall(0);

   804     TInt countBeforeInstall(0);

   805     bool existsAfterInstall(false);

   806     

   807     TComponentId unComponentId;

   808     TRAP_IGNORE(unComponentId = iInstaller->GetComponentIdL(installedUid))

   809     

   810     if( unComponentId > 0 )

   811         {

   812         TRAP_IGNORE(iInstaller->UninstallL(unComponentId));

   813         }

   814 

   815     QScopedPointer<CCaSrvAppScanner> appScanner;

   816     QT_TRAP_THROWING(appScanner.reset(CCaSrvAppScanner::NewL(*iStorage,*iScr,

   817                                         *iSrvEngUtils)))

   818 

   819 

   820     QTest::qWait(7000 * TIMEOUT_FACTOR);

   821 

   822     RPointerArray<CCaInnerEntry> array;

   823     InnerEntryRArrayPointer resultArray(&array);

   824 

   825     QScopedPointer<CDesC16ArrayFlat> appType;

   826 

   827     QT_TRAP_THROWING(appType.reset(new(ELeave) CDesC16ArrayFlat(1)))

   828 

   829     TRAPD(err, appType->AppendL(KCaTypeApp))

   830     QCOMPARE(err, KErrNone);

   831     

   832     QScopedPointer<CCaInnerQuery> query;

   833 

   834     QT_TRAP_THROWING(query.reset(CCaInnerQuery::NewL()));

   835 

   836     query->SetEntryTypeNames(appType.take());

   837     TRAP(err, query->SetParentId(appScanner->GetCollectionDownloadIdL()));

   838     QCOMPARE(err, KErrNone);

   839     query->SetFlagsOn(EVisible);

   840     query->SetFlagsOff(EMissing);

   841 

   842     TRAP(err, iStorage->GetEntriesL(query.data(), *resultArray))

   843     QCOMPARE(err, KErrNone);

   844     

   845     countBeforeInstall =  resultArray->Count();

   846     resultArray->Reset();

   847 

   848     TRAP(err, iInstaller->InstallL(KSapiPackageFileName))

   849     QCOMPARE(err, KErrNone);

   850     

   851     TRAP(err, iInstaller->InstallL(KSapiPackageFileName))

   852     QCOMPARE(err, KErrNone);

   853     

   854     QTest::qWait(20000 * TIMEOUT_FACTOR);

   855 

   856     TComponentId componentId(0);

   857     TRAP(err, componentId = iInstaller->GetComponentIdL(installedUid));

   858     QCOMPARE(err, KErrNone);

   859     

   860     TRAP(err, iStorage->GetEntriesL(query.data(), *resultArray))

   861     QCOMPARE(err, KErrNone);

   862     

   863     countAfterInstall  =  resultArray->Count();

   864 

   865     TRAP(err, existsAfterInstall =

   866         (iTestUtils->ComponentExistsInStorageL(

   867                               componentId, iStorage) != FALSE));

   868     QCOMPARE(err, KErrNone);

   869     

   870     TRAP(err, iInstaller->UninstallL(componentId))

   871     QCOMPARE(err, KErrNone);

   872 

   873     QVERIFY(countAfterInstall == countBeforeInstall + 1);

   874     QVERIFY(existsAfterInstall);

   875 }

   876 // ---------------------------------------------------------------------------

   877 //

   878 // ---------------------------------------------------------------------------

   879 //

   880 void T_casrvAppScaner::testDownloadCollectionRemove()

   881 {

   882     TInt countBeforeInstall(0);

   883     TInt countAfterInstall(0);

   884     TInt countAfterRemove(0);

   885     bool existsAfterInstall(false);

   886     

   887     // ensure the application is not installed

   888     TComponentId unComponentId;

   889     TRAP_IGNORE(unComponentId = iInstaller->GetComponentIdL(installedUid))

   890     

   891     if( unComponentId > 0 )

   892         {

   893         TRAP_IGNORE(iInstaller->UninstallL(unComponentId));

   894         }

   895 

   896     QScopedPointer<CCaSrvAppScanner> appScanner;

   897     QT_TRAP_THROWING(appScanner.reset(CCaSrvAppScanner::NewL(*iStorage,*iScr,

   898                                          *iSrvEngUtils)))

   899 

   900     QTest::qWait(7000 * TIMEOUT_FACTOR);

   901 

   902     RPointerArray<CCaInnerEntry> array;

   903     InnerEntryRArrayPointer resultArray(&array);

   904 

   905     QScopedPointer<CDesC16ArrayFlat> appType;

   906 

   907     TRAPD(error, appType.reset(new(ELeave) CDesC16ArrayFlat(1)));

   908     QCOMPARE(error, KErrNone);

   909 

   910     QScopedPointer<CCaInnerQuery> query;

   911 

   912     TRAP(error, query.reset(CCaInnerQuery::NewL()));

   913     QCOMPARE(error, KErrNone);

   914 

   915     appType->AppendL(KCaTypeApp);

   916 

   917     query->SetEntryTypeNames(appType.take());

   918 

   919     TInt dcID(0);

   920 

   921     TRAP(error, dcID = appScanner->GetCollectionDownloadIdL());

   922     QCOMPARE(error, KErrNone);

   923 

   924     query->SetParentId(dcID);

   925     query->SetFlagsOn(EVisible);

   926     query->SetFlagsOff(EMissing);

   927 

   928     TRAP(error, iStorage->GetEntriesL(query.data(), *resultArray));

   929     QCOMPARE(error, KErrNone);

   930     countBeforeInstall =  resultArray->Count();

   931 

   932     TRAP(error, iInstaller->InstallL(KSapiPackageFileName));

   933     QCOMPARE(error, KErrNone);

   934 

   935     QTest::qWait(20000 * TIMEOUT_FACTOR);

   936 

   937     TComponentId componentId(0);

   938     TRAP(error, componentId = iInstaller->GetComponentIdL(installedUid));

   939     QCOMPARE(error, KErrNone);

   940 

   941     TRAP(error, iStorage->GetEntriesL(query.data(), *resultArray));

   942     QCOMPARE(error, KErrNone);

   943     countAfterInstall =  resultArray->Count();

   944 

   945     if (countAfterInstall >= 1) {

   946         TRAP(error, appScanner->RemoveEntryFromDownloadedL(

   947             (*resultArray)[countAfterInstall-1]->GetId()));

   948         QCOMPARE(error, KErrNone);

   949     }

   950 

   951     RPointerArray<CCaInnerEntry> arrayA;

   952     InnerEntryRArrayPointer resultArrayA(&arrayA);

   953 

   954     TRAP(error, iStorage->GetEntriesL(query.data(), *resultArrayA));

   955     QCOMPARE(error, KErrNone);

   956     countAfterRemove =  resultArrayA->Count();

   957 

   958     TRAP(error, existsAfterInstall =

   959         iTestUtils->ComponentExistsInStorageL(componentId, iStorage));

   960     QCOMPARE(error, KErrNone);

   961 

   962     TRAP(error, iInstaller->UninstallL(componentId));

   963     QCOMPARE(error, KErrNone);

   964 

   965     QVERIFY(countAfterInstall == countBeforeInstall + 1);

   966     QVERIFY(countBeforeInstall == countAfterRemove);

   967     QVERIFY(existsAfterInstall);

   968 }

   969 

   970 // ---------------------------------------------------------------------------

   971 //

   972 // ---------------------------------------------------------------------------

   973 //

   974 void T_casrvAppScaner::testCreatePredefinedCollection()

   975 {

   976     _LIT16( KPredefinedCollection, "Predefined" );

   977 

   978     TInt predefinedCollectionId( 0 );

   979 

   980     TRAPD(err,

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

   982                   *iScr, *iSrvEngUtils);

   983           CleanupStack::PushL(appScanner);

   984           QTest::qWait(7000 * TIMEOUT_FACTOR);

   985           // create predefined collection

   986           predefinedCollectionId = appScanner->CreatePredefinedCollectionL(

   987                   KPredefinedCollection );

   988 

   989 

   990           CleanupStack::PopAndDestroy(appScanner);

   991          );

   992     QCOMPARE( err, KErrNone );

   993     

   994     // clean db after test

   995     if (predefinedCollectionId) {

   996         RArray<TInt> idsToRemove;

   997         CleanupClosePushL(idsToRemove);

   998         TRAP(err, idsToRemove.AppendL( predefinedCollectionId );

   999             iStorage->RemoveL(idsToRemove));

  1000         CleanupStack::PopAndDestroy( &idsToRemove );

  1001     }

  1002 

  1003     QCOMPARE(err, KErrNone);

  1004     QVERIFY(predefinedCollectionId); // all collection id from db

  1005 }

  1006 

  1007 // ---------------------------------------------------------------------------

  1008 //

  1009 // ---------------------------------------------------------------------------

  1010 //

  1011 void T_casrvAppScaner::testGetAllCollectionIdL()

  1012 {

  1013     TInt allCollectionId(0);

  1014     const TInt referenceAllCollectionId(1);

  1015 

  1016     TRAPD(err,

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

  1018                   *iScr, *iSrvEngUtils);

  1019           CleanupStack::PushL(appScanner);

  1020           QTest::qWait(7000 * TIMEOUT_FACTOR);

  1021           // get all collection id

  1022           allCollectionId = appScanner->GetAllCollectionIdL();

  1023 

  1024           CleanupStack::PopAndDestroy(appScanner);

  1025          );

  1026     QCOMPARE( err, KErrNone );

  1027     QCOMPARE( allCollectionId, referenceAllCollectionId );

  1028 }

  1029 

  1030 

  1031 // ---------------------------------------------------------------------------

  1032 //

  1033 // ---------------------------------------------------------------------------

  1034 //

  1035 

  1036 void T_casrvAppScaner::testUpdateComponentIdL()

  1037 {

  1038     TBool updatedWhenNotExists = EFalse;

  1039     TBool updatedAfterInstall = EFalse;

  1040     TBool updatedWhenNoChange = EFalse;

  1041 

  1042     RBuf actualComponentId;

  1043     RBufPointer actualComponentIdPointer(&actualComponentId);

  1044     TBool componentIdAttributeFoundWhenNotExists = EFalse;

  1045     TBool componentIdAttributeFoundAfterInstall = EFalse;

  1046 

  1047     // create app scanner to test

  1048     QScopedPointer<CCaSrvAppScanner> appScanner;

  1049     QT_TRAP_THROWING(appScanner.reset(CCaSrvAppScanner::NewL(*iStorage,

  1050             *iScr, *iSrvEngUtils)))

  1051 

  1052     QScopedPointer<CCaInnerEntry> entry;

  1053     QT_TRAP_THROWING(entry.reset(CCaInnerEntry::NewL()))

  1054 

  1055     // case 1: pass non existing application description

  1056     entry->SetUid(0);

  1057     

  1058     TRAPD(err, updatedWhenNotExists =

  1059         appScanner->UpdateComponentIdL(*entry))

  1060     QCOMPARE(err, KErrNone);

  1061 

  1062     TRAP(err, actualComponentIdPointer->CreateL(KCaMaxAttrValueLen))

  1063     QCOMPARE(err, KErrNone);

  1064     

  1065     componentIdAttributeFoundWhenNotExists =

  1066         entry->FindAttribute(KCaComponentId, *actualComponentIdPointer);

  1067 

  1068 

  1069     // case 2: add component id once application is installed

  1070 

  1071     // ensure the application is not installed

  1072     TComponentId unComponentId;

  1073     TRAP_IGNORE(unComponentId = iInstaller->GetComponentIdL(installedUid))

  1074 

  1075     if( unComponentId > 0 )

  1076         {

  1077         TRAP_IGNORE(iInstaller->UninstallL(unComponentId));

  1078         }

  1079 

  1080     TRAP(err, iInstaller->InstallL(KSapiPackageFileName))

  1081     QCOMPARE(err, KErrNone);

  1082     

  1083     TComponentId componentId(0);

  1084     TRAP(err, componentId = iInstaller->GetComponentIdL(installedUid));

  1085     QCOMPARE(err, KErrNone);

  1086 

  1087     entry->SetUid(installedUid);

  1088     TRAP(err, updatedAfterInstall =

  1089         appScanner->UpdateComponentIdL(*entry));

  1090     QCOMPARE(err, KErrNone);

  1091     

  1092     actualComponentIdPointer->Close();

  1093     TRAP(err, actualComponentIdPointer->CreateL(KCaMaxAttrValueLen))

  1094     QCOMPARE(err, KErrNone);

  1095     

  1096     componentIdAttributeFoundAfterInstall =

  1097         entry->FindAttribute(KCaComponentId, *actualComponentIdPointer);

  1098 

  1099     // case 3: update for application which has component id not changed

  1100     TRAP(err, updatedWhenNoChange =

  1101         appScanner->UpdateComponentIdL(*entry))

  1102     QCOMPARE(err, KErrNone);

  1103     

  1104     QVERIFY(!updatedWhenNotExists);

  1105     QVERIFY(!componentIdAttributeFoundWhenNotExists);

  1106     QVERIFY(updatedAfterInstall);

  1107     QVERIFY(componentIdAttributeFoundAfterInstall);

  1108     QVERIFY(!updatedWhenNoChange);

  1109 }

  1110 

  1111 // ---------------------------------------------------------------------------

  1112 //

  1113 // ---------------------------------------------------------------------------

  1114 //

  1115 void T_casrvAppScaner::testSave()

  1116 {

  1117     bool result(false);

  1118     TRAPD(err,

  1119           RFs fs;

  1120           User::LeaveIfError(fs.Connect());

  1121             {

  1122             CCaSrvMmcHistory* mmcHist = CCaSrvMmcHistory::NewL();

  1123             CleanupStack::PushL( mmcHist );

  1124             mmcHist->InsertL(1);

  1125             mmcHist->SaveL(fs, _L("c:\\testing\\data\\t_caappscanner\\testmmchist"));

  1126             CleanupStack::PopAndDestroy( mmcHist );

  1127 

  1128             mmcHist = CCaSrvMmcHistory::NewL();

  1129             CleanupStack::PushL( mmcHist );

  1130             mmcHist->LoadL(fs, _L("c:\\testing\\data\\t_caappscanner\\testmmchist"));

  1131             result = (mmcHist->Find(1) != KErrNotFound);

  1132             CleanupStack::PopAndDestroy( mmcHist );

  1133             }

  1134         );

  1135     QCOMPARE(err, KErrNone);