1 /*

     2 * Copyright (c) 2009 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 /*

    18  * castoragetesttouch.cpp

    19  *

    20  *  Created on: 2009-08-17

    21  *      Author: michal.wojcik

    22  */

    23 

    24 #include "castoragetest.h"

    25 #include "castoragefactory.h"

    26 #include "castorage.h"

    27 #include "cainnerentry.h"

    28 #include "casqlquery.h"

    29 #include "casqlitestorage.h"

    30 #include "castoragetestsqlcommands.h"

    31 #include "casqlcommands.h"

    32 

    33 // ============================ MEMBER FUNCTIONS ===============================

    34 

    35 // ---------------------------------------------------------------------------

    36 //

    37 // ---------------------------------------------------------------------------

    38 //

    39 void CCAStorageTest::testTouch()

    40 {

    41     TInt err(KErrGeneral);

    42 

    43     __UHEAP_MARK;

    44     TRAP(err,

    45          // check database before touch

    46          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

    47          query->SetQueryL(KSQLGetIdCountFromLaunchTable);

    48          query->PrepareL();

    49          TInt countLaunchBeforeTouch(0);

    50          query->ExecuteL(countLaunchBeforeTouch);

    51          CleanupStack::PopAndDestroy(query);

    52 

    53          // Id 14 - Clock app

    54          mStorage->TouchL(14, ETrue);

    55 

    56          // check database after touch

    57          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

    58          query->SetQueryL(KSQLGetIdCountFromLaunchTable);

    59          query->PrepareL();

    60          TInt countLaunchAfterTouch(0);

    61          query->ExecuteL(countLaunchAfterTouch);

    62          CleanupStack::PopAndDestroy(query);

    63 

    64          // flag should be set to EUsed on 1 Entry

    65          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

    66          query->SetQueryL(KSQLGetUsedFlagCountFromEntryTable);

    67          query->PrepareL();

    68          query->BindValuesForLaunchL(0,0);

    69          TInt countEntriesWithUsedFlag(0);

    70          query->ExecuteL(countEntriesWithUsedFlag);

    71          CleanupStack::PopAndDestroy(query);

    72 

    73     if (((countLaunchAfterTouch - countLaunchBeforeTouch) == 1) && (countEntriesWithUsedFlag == 1)) {

    74     err = KErrNone;

    75 } else {

    76     err = KErrGeneral;

    77 }

    78     );

    79     __UHEAP_MARKEND;

    80 

    81     QCOMPARE(err, KErrNone);

    82 }

    83 

    84 void CCAStorageTest::testTouch2Times()

    85 {

    86     TInt err(KErrGeneral);

    87 

    88     __UHEAP_MARK;

    89     TRAP(err,

    90          // check database before touch

    91          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

    92          query->SetQueryL(KSQLGetIdCountFromLaunchTable);

    93          query->PrepareL();

    94          TInt countLaunchBeforeTouch(0);

    95          query->ExecuteL(countLaunchBeforeTouch);

    96          CleanupStack::PopAndDestroy(query);

    97 

    98          // Id 14 - Clock app

    99          mStorage->TouchL(14, ETrue);//removable application

   100          User::After(1000000); // 1 sec

   101          mStorage->TouchL(14, ETrue);

   102 

   103          // check database after touch

   104          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   105          query->SetQueryL(KSQLGetIdCountFromLaunchTable);

   106          query->PrepareL();

   107          TInt countLaunchAfterTouch(0);

   108          query->ExecuteL(countLaunchAfterTouch);

   109          CleanupStack::PopAndDestroy(query);

   110 

   111          // flag should be set to EUsed on 1 Entry

   112          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   113          query->SetQueryL(KSQLGetUsedFlagCountFromEntryTable);

   114          query->PrepareL();

   115          query->BindValuesForLaunchL(0,0);

   116          TInt countEntriesWithUsedFlag(0);

   117          query->ExecuteL(countEntriesWithUsedFlag);

   118          CleanupStack::PopAndDestroy(query);

   119 

   120     if (((countLaunchAfterTouch - countLaunchBeforeTouch) == 2) && (countEntriesWithUsedFlag == 1)) {

   121     err = KErrNone;

   122 } else {

   123     err = KErrGeneral;

   124 }

   125     );

   126 

   127     __UHEAP_MARKEND;

   128 

   129     QCOMPARE(err, KErrNone);

   130 }

   131 

   132 void CCAStorageTest::testTouch5Entries()

   133 {

   134     TInt err(KErrGeneral);

   135 

   136     __UHEAP_MARK;

   137 

   138     TRAP(err,

   139          // check database before touch

   140          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   141          query->SetQueryL(KSQLGetIdCountFromLaunchTable);

   142          query->PrepareL();

   143          TInt countLaunchBeforeTouch(0);

   144          query->ExecuteL(countLaunchBeforeTouch);

   145          CleanupStack::PopAndDestroy(query);

   146         //all apps are not removeable

   147          mStorage->TouchL(9, EFalse);  // calendar

   148          mStorage->TouchL(10, EFalse); // calculator

   149          mStorage->TouchL(16, EFalse); // music player

   150          mStorage->TouchL(20, EFalse); // photos

   151          mStorage->TouchL(21, EFalse); // video center

   152 

   153          // check database after touch

   154          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   155          query->SetQueryL(KSQLGetIdCountFromLaunchTable);

   156          query->PrepareL();

   157          TInt countLaunchAfterTouch(0);

   158          query->ExecuteL(countLaunchAfterTouch);

   159          CleanupStack::PopAndDestroy(query);

   160 

   161          // flag should be set to EUsed on 5 Entries

   162          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   163          query->SetQueryL(KSQLGetUsedFlagCountFromEntryTable);

   164          query->PrepareL();

   165          query->BindValuesForLaunchL(0,0);

   166          TInt countEntriesWithUsedFlag(0);

   167          query->ExecuteL(countEntriesWithUsedFlag);

   168          CleanupStack::PopAndDestroy(query);

   169 

   170     if (((countLaunchAfterTouch - countLaunchBeforeTouch) == 5) && (countEntriesWithUsedFlag == 0)) {

   171     err = KErrNone;

   172 } else {

   173     err = KErrGeneral;

   174 }

   175     );

   176     __UHEAP_MARKEND;

   177 

   178     QCOMPARE(err, KErrNone);

   179 }

   180 

   181 void CCAStorageTest::testRemoveOldFromLaunch()

   182 {

   183     TInt err(KErrGeneral);

   184 

   185     __UHEAP_MARK;

   186     TRAP(err,

   187          // prepare time older than 30 days

   188          TTime presentTime;

   189          presentTime.UniversalTime();

   190          TTime outOfDateTime = presentTime - (TTimeIntervalDays(30 + 5));

   191 

   192          // prepare item with launch time older than 30 days

   193          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   194          query->SetQueryL(KSQLInsertToLaunch);

   195          query->PrepareL();

   196          // change launch time for calculator app to older than 30 days

   197          query->BindValuesForLaunchL(10, outOfDateTime.Int64());

   198          query->ExecuteL();

   199          CleanupStack::PopAndDestroy(query);

   200          // prepare 2 items with launch time newer than 30 days

   201          mStorage->TouchL(20, EFalse); // photos

   202          mStorage->TouchL(21, EFalse); // video center

   203 

   204          // check database before remove old launch

   205          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   206          query->SetQueryL(KSQLGetIdCountFromLaunchTable);

   207          query->PrepareL();

   208          TInt countLaunchBeforeRemove(0);

   209          query->ExecuteL(countLaunchBeforeRemove);

   210          CleanupStack::PopAndDestroy(query);

   211 

   212          // remove launches older than 30 days

   213          ((CCaSqLiteStorage *)mStorage)->RemoveOldEntriesFromLaunchTableL(30);

   214 

   215          // check database after remove old launches

   216          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   217          query->SetQueryL(KSQLGetIdCountFromLaunchTable);

   218          query->PrepareL();

   219          TInt countLaunchAfterRemove(0);

   220          query->ExecuteL(countLaunchAfterRemove);

   221          CleanupStack::PopAndDestroy(query);

   222 

   223     if ((countLaunchBeforeRemove - countLaunchAfterRemove) == 1) {

   224     err = KErrNone;

   225 } else {

   226     err = KErrGeneral;

   227 }

   228     );

   229     __UHEAP_MARKEND;

   230 

   231     QCOMPARE(err, KErrNone);

   232 }

   233 

   234 void CCAStorageTest::testRemoveOldWhen2DifferentLaunchTimes()

   235 {

   236     TInt err(KErrGeneral);

   237 

   238     __UHEAP_MARK;

   239     TRAP(err,

   240          // prepare time older than 30 days

   241          TTime presentTime;

   242          presentTime.UniversalTime();

   243          TTime outOfDateTime = presentTime - (TTimeIntervalDays(30 + 5));

   244 

   245          // prepare item with launch time older than 30 days

   246          CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   247          query->SetQueryL(KSQLInsertToLaunch);

   248          query->PrepareL();

   249          // change launch time for calculator app to older than 30 days

   250          query->BindValuesForLaunchL(10, outOfDateTime.Int64());

   251          query->ExecuteL();

   252          CleanupStack::PopAndDestroy(query);

   253          // prepare 2 items with launch time newer than 30 days

   254          mStorage->TouchL(10, EFalse); // launch the same app again - time newer than 30 days

   255 

   256          // check database before remove old launch

   257          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   258          query->SetQueryL(KSQLGetIdCountFromLaunchTable);

   259          query->PrepareL();

   260          TInt countLaunchBeforeRemove(0);

   261          query->ExecuteL(countLaunchBeforeRemove);

   262          CleanupStack::PopAndDestroy(query);

   263 

   264          // remove launches older than 30 days

   265          ((CCaSqLiteStorage *)mStorage)->RemoveOldEntriesFromLaunchTableL(30);

   266 

   267          // check database after remove old launches

   268          query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   269          query->SetQueryL(KSQLGetIdCountFromLaunchTable);

   270          query->PrepareL();

   271          TInt countLaunchAfterRemove(0);

   272          query->ExecuteL(countLaunchAfterRemove);

   273          CleanupStack::PopAndDestroy(query);

   274 

   275     if ((countLaunchBeforeRemove - countLaunchAfterRemove) == 1) {

   276     err = KErrNone;

   277 } else {

   278     err = KErrGeneral;

   279 }

   280     );

   281     __UHEAP_MARKEND;

   282 

   283     QCOMPARE(err, KErrNone);

   284 }