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  * castoragetestlocalization.cpp

    19  *

    20  *  Created on: Dec 2, 2009

    21  *      Author: michal.wojcik

    22  */

    23 

    24 

    25 #include "castoragetest.h"

    26 #include "castoragefactory.h"

    27 #include "castorage.h"

    28 #include "caarraycleanup.inl"

    29 #include "cainnerentry.h"

    30 #include "calocalizationentry.h"

    31 #include "casqlquery.h"

    32 #include "casqlitestorage.h"

    33 #include "castoragetestsqlcommands.h"

    34 #include "casqlcommands.h"

    35 

    36 // ============================ MEMBER FUNCTIONS ===============================

    37 

    38 // ---------------------------------------------------------------------------

    39 //

    40 // ---------------------------------------------------------------------------

    41 //

    42 void CCAStorageTest::testRemoveFromLocalizationAfterNameChange()

    43 {

    44     TInt err(KErrGeneral);

    45 

    46     __UHEAP_MARK;

    47     TRAP(err,

    48          // Check before test

    49          CCaSqlQuery *query = CCaSqlQuery::NewL(((CCaSqLiteStorage *)mStorage)->iSqlDb);

    50          CleanupStack::PushL(query);

    51          query->SetQueryL(KSQLCountFromLocalizationTable);

    52          query->PrepareL();

    53          TInt countLocalizationBefore(0);

    54          query->ExecuteL(countLocalizationBefore);

    55          CleanupStack::PopAndDestroy(query);

    56 

    57          // Update Collection Name;

    58          //    CCaInnerEntry* innerEntry = CCaInnerEntry::NewLC();

    59          //    innerEntry->SetId( 5 );

    60          //    innerEntry->SetTextL( KTestName );

    61          //    mStorage->AddL( innerEntry );

    62          //    CleanupStack::PopAndDestroy( innerEntry );

    63 

    64          mStorage->RemoveFromLocalizationL(5);

    65 

    66 

    67          // Check result after name entry name update

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

    69          query->SetQueryL(KSQLCountFromLocalizationTable);

    70          query->PrepareL();

    71          TInt countLocalizationAfter(0);

    72          query->ExecuteL(countLocalizationAfter);

    73          CleanupStack::PopAndDestroy(query);

    74     if ((countLocalizationBefore - countLocalizationAfter) == 1) {

    75     err = KErrNone;

    76 }

    77     );

    78     __UHEAP_MARKEND;

    79 

    80     QCOMPARE(err, KErrNone);

    81 }

    82 

    83 void CCAStorageTest::testGetLocalizations()

    84 {

    85     TInt err(KErrGeneral);

    86 

    87     __UHEAP_MARK;

    88     TRAP(err,

    89          // Check before test

    90          CCaSqlQuery *query = CCaSqlQuery::NewL(((CCaSqLiteStorage *)mStorage)->iSqlDb);

    91          CleanupStack::PushL(query);

    92          query->SetQueryL(KSQLCountFromLocalizationTable);

    93          query->PrepareL();

    94          TInt countLocalization(0);

    95          query->ExecuteL(countLocalization);

    96          CleanupStack::PopAndDestroy(query);

    97 

    98          // Get Localizations from db

    99          RPointerArray<CCaLocalizationEntry> resultContainer;

   100          CleanupResetAndDestroyPushL(resultContainer);

   101          mStorage->GetLocalizationsL(resultContainer);

   102 

   103         if (resultContainer.Count() == countLocalization) {

   104             err = KErrNone;

   105         }

   106 

   107         CleanupStack::PopAndDestroy(&resultContainer);

   108     );

   109     __UHEAP_MARKEND;

   110 

   111     QCOMPARE(err, KErrNone);

   112 }

   113 

   114 void CCAStorageTest::testLocalizeEntry()

   115 {

   116     TInt err(KErrGeneral);

   117 

   118     __UHEAP_MARK;

   119     TRAP(err,

   120          CCaLocalizationEntry *localizationEntry = CCaLocalizationEntry::NewLC();

   121 

   122          const TInt KOfficeId = 5;

   123 

   124          _LIT(KAttributeName, "EN_TEXT");

   125          localizationEntry->SetAttributeNameL(KAttributeName);

   126          _LIT(KNewLocalizedString, "Biurowe smietnisko");

   127          localizationEntry->SetLocalizedStringL(KNewLocalizedString);

   128          localizationEntry->SetRowId(KOfficeId);   // office

   129          _LIT(KTableName, "CA_ENTRY");

   130          localizationEntry->SetTableNameL(KTableName);

   131          localizationEntry->SetTextId(KOfficeId);    // office

   132 

   133          // test localize entry

   134          mStorage->LocalizeEntryL(*localizationEntry);

   135 

   136          // get this entry from db - office

   137          CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();

   138          RArray<TInt> idArray;

   139          CleanupClosePushL(idArray);

   140          idArray.AppendL(KOfficeId);

   141          innerQuery->SetIdsL(idArray);

   142 

   143          RPointerArray<CCaInnerEntry> resultArray;

   144          CleanupResetAndDestroyPushL(resultArray);

   145          mStorage->GetEntriesL(innerQuery, resultArray);

   146 

   147          // check results

   148     if (!resultArray[0]->GetText().CompareC(KNewLocalizedString)) {

   149     err = KErrNone;

   150 }

   151 

   152 CleanupStack::PopAndDestroy(&resultArray);

   153 CleanupStack::PopAndDestroy(&idArray);

   154 CleanupStack::PopAndDestroy(innerQuery);

   155 

   156 CleanupStack::PopAndDestroy(localizationEntry);

   157     );

   158     __UHEAP_MARKEND;

   159 

   160     QCOMPARE(err, KErrNone);

   161 }

   162 

   163 

   164 //-------------------------------------------------------------------------

   165 void CCAStorageTest::testAddLocalizationEntry()

   166 {

   167     TInt err(KErrGeneral);

   168     TInt countLocalization1(0);

   169     TInt countLocalization2(0);

   170 

   171     __UHEAP_MARK;

   172     TRAP(err,

   173          // Check before test

   174 

   175         countLocalization1 = locEntriesCount();

   176          // Get Localizations from db

   177         CCaLocalizationEntry* locEntry = CCaLocalizationEntry::NewLC();

   178         locEntry->SetTableNameL(_L("TestTable"));

   179         locEntry->SetAttributeNameL(_L("TestAttName"));

   180         locEntry->SetStringIdL(_L("TestStrId"));

   181         locEntry->SetQmFilenameL(_L("TestQmFilename"));

   182         locEntry->SetRowId(6667);

   183         mStorage->AddLocalizationL(*locEntry);

   184         countLocalization2 =locEntriesCount();

   185         CleanupStack::PopAndDestroy(locEntry);

   186 

   187         );

   188     QCOMPARE(err, KErrNone); 

   189     QCOMPARE(countLocalization1+1 , countLocalization2);

   190          

   191     __UHEAP_MARKEND;

   192     

   193 }

   194 

   195 //-------------------------------------------------------------------------

   196 void CCAStorageTest::testUpdateLocalizationEntry()

   197 {

   198     TInt err(KErrGeneral);

   199     TInt countLocalization1(0);

   200     TInt countLocalization2(0);

   201     

   202     __UHEAP_MARK;

   203     TRAP(err,

   204          // Get Localizations from db

   205          CCaLocalizationEntry* locEntry = CCaLocalizationEntry::NewLC();

   206          locEntry->SetTableNameL(_L("TestTable"));

   207          locEntry->SetAttributeNameL(_L("TestAttName"));

   208          locEntry->SetStringIdL(_L("TestStrId"));

   209          locEntry->SetQmFilenameL(_L("TestQmFilename"));

   210          locEntry->SetRowId(6668);

   211          mStorage->AddLocalizationL(*locEntry);

   212          

   213          countLocalization1 = locEntriesCount();

   214 

   215          locEntry->SetTableNameL(_L("TestTable"));

   216          locEntry->SetAttributeNameL(_L("TestAttName"));

   217          locEntry->SetStringIdL(_L("TestStrId2"));

   218          locEntry->SetQmFilenameL(_L("TestQmFilename2"));

   219          locEntry->SetRowId(6668);

   220          mStorage->AddLocalizationL(*locEntry);

   221 

   222          countLocalization2 = locEntriesCount();

   223          

   224          CleanupStack::PopAndDestroy(locEntry);

   225        

   226         );

   227     QCOMPARE(err, KErrNone); 

   228     QCOMPARE(countLocalization1 , countLocalization2);

   229          

   230     __UHEAP_MARKEND;

   231     

   232 }

   233 //-------------------------------------------------------------------------

   234 TInt CCAStorageTest::locEntriesCount()

   235 {

   236     TInt count(0);

   237     CCaSqlQuery *query = CCaSqlQuery::NewL(((CCaSqLiteStorage *)mStorage)->iSqlDb);

   238     CleanupStack::PushL(query);

   239     query->SetQueryL(KSQLCountFromLocalizationTable);

   240     query->PrepareL();

   241     query->ExecuteL(count);

   242     CleanupStack::PopAndDestroy(query);

   243     return count;

   244 }