--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/contentstorage/castorage/tsrc/t_castorage/src/castoragetestgetentries.cpp Thu Sep 16 12:11:40 2010 +0100
@@ -0,0 +1,1480 @@
+/*
+* Copyright (c) 2009 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:
+*
+*/
+/*
+ * castoragetestgetentries.cpp
+ *
+ * Created on: 2009-08-05
+ * Author: michal.czerwiec
+ */
+
+#include <e32cmn.h>
+#include <mmf/common/mmfcontrollerpluginresolver.h>
+#include <badesca.h>
+#include <e32math.h>
+#include <qglobal.h>
+
+#include "castoragetest.h"
+#include "cainnerquery.h"
+#include "castoragefactory.h"
+#include "castorage.h"
+#include "cainnerentry.h"
+#include "castoragetestsqlcommands.h"
+#include "casqlcommands.h"
+#include "casqlquery.h"
+#include "casqlitestorage.h"
+#include "cadef.h"
+
+
+// ---------------------------------------------------------------------------
+// Test that two data arrays have opposite order.
+//
+// ---------------------------------------------------------------------------
+//
+TInt CCAStorageTest::verifyOppositeOrder(RPointerArray<CCaInnerEntry>& aArray1,
+ RPointerArray<CCaInnerEntry>& aArray2)
+{
+ TInt err;
+
+ __UHEAP_MARK;
+
+ err = (aArray1.Count() == aArray2.Count())? KErrNone : KErrWrongData;
+ if (!err) {
+ TInt count(aArray1.Count());
+ for (TInt i = 0; i < aArray1.Count(); i++) {
+ if (aArray1[i]->GetId() != aArray2[count-1-i]->GetId()) {
+ err = KErrWrongData;
+ break;
+ }
+ }
+ }
+
+ __UHEAP_MARKEND;
+
+ return err;
+}
+
+// ---------------------------------------------------------------------------
+// Test Sorting Order giving different attributes.
+//
+// ---------------------------------------------------------------------------
+//
+TInt CCAStorageTest::testSortingBySortOrder(CCaInnerQuery::TSortAttribute sortAttr1,
+ CCaInnerQuery::TSortAttribute sortAttr2)
+{
+
+ __UHEAP_MARK;
+
+ TRAPD(err,
+ CCaInnerQuery *innerQuery1 = CCaInnerQuery::NewLC();
+ innerQuery1->SetSort(sortAttr1);
+
+ CCaInnerQuery *innerQuery2 = CCaInnerQuery::NewLC();
+ innerQuery2->SetSort(sortAttr2);
+
+ err = testSortingBySortOrder(innerQuery1, innerQuery2);
+
+ CleanupStack::PopAndDestroy(innerQuery2);
+ CleanupStack::PopAndDestroy(innerQuery1);
+ );
+ __UHEAP_MARKEND;
+
+ return err;
+}
+
+
+// ---------------------------------------------------------------------------
+// Test Sorting Order giving different attributes.
+//
+// ---------------------------------------------------------------------------
+//
+TInt CCAStorageTest::testSortingBySortOrder(CCaInnerQuery *aInnerQuery1,
+ CCaInnerQuery *aInnerQuery2)
+{
+ __UHEAP_MARK;
+ TInt err(KErrNone);
+ RPointerArray<CCaInnerEntry> resultArray;
+ TRAP(err,
+ CleanupResetAndDestroyPushL(resultArray);
+ mStorage->GetEntriesL(aInnerQuery1,resultArray);
+
+ RPointerArray<CCaInnerEntry> resultArrayDesc;
+ CleanupResetAndDestroyPushL(resultArrayDesc);
+ mStorage->GetEntriesL(aInnerQuery2,resultArrayDesc);
+
+ err = (resultArray.Count() > 0)? KErrNone : KErrWrongData;
+
+ if (err == KErrNone) {
+ err = (resultArrayDesc.Count() > 0)? KErrNone : KErrWrongData;
+ }
+
+ if (err == KErrNone) {
+ err = verifyOppositeOrder(resultArray, resultArrayDesc);
+ }
+ CleanupStack::PopAndDestroy(&resultArrayDesc);
+ CleanupStack::PopAndDestroy(&resultArray);
+ );
+
+
+ __UHEAP_MARKEND;
+
+ return err;
+}
+// ---------------------------------------------------------------------------
+// Test Select several entries by id.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesById()
+{
+ __UHEAP_MARK;
+ {
+ QList<TInt> expectedIdList;
+ expectedIdList << 1 << 2 << 3 << 4 << 5 << 6;
+ QList<TInt> actualIdList;
+
+
+ TRAPD(err,
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ RArray<TInt> idArray;
+ CleanupClosePushL(idArray);
+ idArray.AppendL(expectedIdList[0]);
+ idArray.AppendL(expectedIdList[1]);
+ idArray.AppendL(expectedIdList[2]);
+ idArray.AppendL(expectedIdList[3]);
+ idArray.AppendL(expectedIdList[4]);
+ idArray.AppendL(expectedIdList[5]);
+
+ innerQuery->SetIdsL(idArray);
+
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+
+ mStorage->GetEntriesL(innerQuery,resultArray);
+
+ // check if the actual items were returned
+ for (TInt i = 0; i < resultArray.Count(); i++) {
+ actualIdList << resultArray[i]->GetId();
+ }
+
+ CleanupStack::PopAndDestroy(&resultArray);
+ CleanupStack::PopAndDestroy(&idArray);
+ CleanupStack::PopAndDestroy(innerQuery);
+ );
+
+
+ QCOMPARE(err, KErrNone);
+ QCOMPARE(actualIdList, expectedIdList);
+ }
+
+ __UHEAP_MARKEND;
+}
+
+// ---------------------------------------------------------------------------
+// Test Select entries by group id.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByGroupId()
+{
+ TInt expectedGroupEntryCount(0);
+ TInt actualGroupEntryCount(0);
+
+ __UHEAP_MARK;
+
+ TRAPD(err,
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+
+ // check before test entries count in sfecific group
+ CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
+ query->SetQueryL(KSQLGetEntriesCountFromSpecificGroup);
+ query->PrepareL();
+ query->BindIntL(query->iStatement.ParameterIndex(KSQLGEIdGroup), KAllCollectionsGroupId);
+
+ query->ExecuteL(expectedGroupEntryCount);
+
+ CleanupStack::PopAndDestroy(query);
+
+ innerQuery->SetParentId(KAllCollectionsGroupId);
+
+ // get entries from specific group
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+
+ mStorage->GetEntriesL(innerQuery, resultArray);
+
+ actualGroupEntryCount = resultArray.Count();
+
+ CleanupStack::PopAndDestroy(&resultArray);
+ CleanupStack::PopAndDestroy(innerQuery);
+ );
+
+ __UHEAP_MARKEND;
+
+ QCOMPARE(err, KErrNone);
+ QCOMPARE(actualGroupEntryCount, expectedGroupEntryCount);
+}
+
+// ---------------------------------------------------------------------------
+// Test Select entries by group id.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByTypeName()
+{
+ bool nonWidgetEntryFound(false);
+ const int expectedNumberOfWidgets(2);
+ int numberOfWidgetsFound(0);
+
+ __UHEAP_MARK;
+
+ _LIT(KTypeNameWidget, "Widget");
+
+ TRAPD(err,
+ // add 2 new entries - typename widget
+ CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
+ innerEntry->SetTextL(KTestName1);
+ innerEntry->SetEntryTypeNameL(KTypeNameWidget);
+ innerEntry->SetFlags(flag);
+ innerEntry->SetRole(CCaInnerQuery::Item);
+ mStorage->AddL(innerEntry);
+ CleanupStack::PopAndDestroy(innerEntry);
+
+ innerEntry = CCaInnerEntry::NewLC();
+ innerEntry->SetTextL(KTestName2);
+ innerEntry->SetEntryTypeNameL(KTypeNameWidget);
+ innerEntry->SetFlags(flag);
+ innerEntry->SetRole(CCaInnerQuery::Item);
+ mStorage->AddL(innerEntry);
+ CleanupStack::PopAndDestroy(innerEntry);
+
+
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ CDesC16ArrayFlat *typenameArray = new(ELeave) CDesC16ArrayFlat(KDefaultGranularity);
+ CleanupStack::PushL(typenameArray);
+
+ TBufC<20> typeName(KTypeNameWidget);
+ typenameArray->AppendL(typeName);
+
+ innerQuery->SetEntryTypeNames(typenameArray);
+ CleanupStack::Pop(typenameArray);
+
+ // get entries from specific group
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+
+
+ // get entries - widgets
+ mStorage->GetEntriesL(innerQuery,resultArray);
+
+ numberOfWidgetsFound = resultArray.Count();
+ // check results
+ for (TInt i = 0; i < numberOfWidgetsFound; ++i) {
+ if ((resultArray[i]->GetEntryTypeName()).Compare(
+ KTypeNameWidget) != 0) {
+ nonWidgetEntryFound = true;
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&resultArray);
+ CleanupStack::PopAndDestroy(innerQuery);
+ );
+ __UHEAP_MARKEND;
+
+ QCOMPARE(err, KErrNone);
+ QCOMPARE(numberOfWidgetsFound, expectedNumberOfWidgets);
+ QVERIFY(!nonWidgetEntryFound);
+}
+
+// ---------------------------------------------------------------------------
+// Test Select entries sorted by name alphabetically.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesSortByName()
+{
+ __UHEAP_MARK;
+ {
+ TInt entriesACount(0);
+ QMap<QString, bool> comparisonAResults;
+ TInt entriesBCount(0);
+ QMap<QString, bool> comparisonBResults;
+ bool orderCheckPassed(false);
+
+ TRAPD(err,
+ // test ascending
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ innerQuery->SetSort(CCaInnerQuery::Name);
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+ mStorage->GetEntriesL(innerQuery,resultArray);
+
+ // change all odd entries texts to be lower case
+ for (TInt i = 0; i < resultArray.Count(); ++i) {
+ if (resultArray[i]->GetId() % 2 == 1) {
+ RBuf tempBuf;
+ tempBuf.CleanupClosePushL();
+ tempBuf.CreateL(resultArray[i]->GetText());
+ tempBuf.LowerCase();
+ resultArray[i]->SetTextL(tempBuf);
+ CleanupStack::PopAndDestroy(&tempBuf);
+ mStorage->AddL(resultArray[i]);
+ }
+ }
+ // fetch the table again
+ resultArray.ResetAndDestroy();
+ mStorage->GetEntriesL(innerQuery,resultArray);
+
+ entriesACount = resultArray.Count();
+
+ RBuf previousText;
+ previousText.CleanupClosePushL();
+ RBuf currentText;
+ currentText.CleanupClosePushL();
+ if (!err) {
+ for (TInt i = 0; i < resultArray.Count(); i++) {
+ currentText.CreateL(resultArray[i]->GetText());
+ currentText.LowerCase();
+
+ comparisonAResults[descToQString(currentText)] = true;
+
+ if (i!=0 && currentText.Compare(previousText) < 0) {
+ comparisonAResults[descToQString(currentText)] = false;
+ err = KErrWrongData;
+ break;
+ }
+ currentText.Close();
+ previousText.Close();
+ previousText.CreateL(resultArray[i]->GetText());
+ previousText.LowerCase();
+ }
+ }
+ // test descending
+ CCaInnerQuery *innerQuery2 = CCaInnerQuery::NewLC();
+ innerQuery2->SetSort(CCaInnerQuery::NameDesc);
+ RPointerArray<CCaInnerEntry> resultArrayDesc;
+ CleanupResetAndDestroyPushL(resultArrayDesc);
+ mStorage->GetEntriesL(innerQuery2,resultArrayDesc);
+
+ entriesBCount = resultArrayDesc.Count();
+
+ previousText.Close();
+ currentText.Close();
+
+ if (!err) {
+ for (TInt i = 0; i < resultArrayDesc.Count(); i++) {
+ currentText.CreateL(resultArrayDesc[i]->GetText());
+ currentText.LowerCase();
+
+ comparisonBResults[descToQString(currentText)] = true;
+
+ if (i!=0 && resultArrayDesc[i]->GetText().Compare(previousText) > 0) {
+ comparisonBResults[descToQString(currentText)] = false;
+ break;
+ }
+ currentText.Close();
+ previousText.Close();
+ previousText.CreateL(resultArrayDesc[i]->GetText());
+ previousText.LowerCase();
+ }
+ }
+
+ if (!err) {
+ orderCheckPassed = verifyOppositeOrder(resultArray, resultArrayDesc) == 0;
+ }
+
+ CleanupStack::PopAndDestroy(&resultArrayDesc);
+ CleanupStack::PopAndDestroy(innerQuery2);
+ CleanupStack::PopAndDestroy(¤tText);
+ CleanupStack::PopAndDestroy(&previousText);
+ CleanupStack::PopAndDestroy(&resultArray);
+ CleanupStack::PopAndDestroy(innerQuery);
+ );
+
+ QCOMPARE(err, KErrNone);
+ foreach(QString str, comparisonAResults.keys()) {
+ QVERIFY2(comparisonAResults[str], str.toUtf8());
+ };
+ QCOMPARE(comparisonAResults.size(), entriesACount);
+
+
+ foreach(QString str, comparisonAResults.keys()) {
+ QVERIFY2(comparisonBResults[str], str.toUtf8());
+ };
+ QCOMPARE(comparisonBResults.size(), entriesBCount);
+
+ QVERIFY(orderCheckPassed);
+ }
+ __UHEAP_MARKEND;
+}
+
+// ---------------------------------------------------------------------------
+// tests getentries sorted by created timestamp ascending.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesSortByCreatedTimestamp()
+{
+
+ __UHEAP_MARK;
+ {
+ QMap<int, bool> ascendingOrderCheckResults;
+ QMap<int, bool> descendingOrderCheckResults;
+
+ TRAPD(err,
+ // check ascending
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ innerQuery->SetSort(CCaInnerQuery::CreatedTimestamp);
+ mStorage->GetEntriesL(innerQuery,resultArray);
+ CleanupStack::PopAndDestroy(innerQuery);
+
+ TInt64 previousTimestamp(0);
+ for (TInt i = 0; i<resultArray.Count() ; i++) {
+ innerQuery = CCaInnerQuery::NewLC();
+ RArray<TInt> ids;
+ CleanupClosePushL(ids);
+ const TInt id = resultArray[i]->GetId();
+ ids.AppendL(id);
+ innerQuery->SetIdsL(ids);
+
+ TInt64 timestamp(0);
+ CCaSqlQuery *query = CCaSqlQuery::NewLC(STATIC_CAST(CCaSqLiteStorage *,mStorage)->iSqlDb);
+ query->SetQueryL(KSQLGetEntryTimestamp);
+ query->PrepareL();
+ query->BindIdsL(ids, KSQLEntryId);
+ query->ExecuteL(timestamp);
+
+ if (i != 0 && timestamp < previousTimestamp) {
+ ascendingOrderCheckResults[id] = false;
+ break;
+ }
+ previousTimestamp = timestamp;
+ CleanupStack::PopAndDestroy(query);
+ CleanupStack::PopAndDestroy(&ids);
+ CleanupStack::PopAndDestroy(innerQuery);
+ }
+
+ CleanupStack::PopAndDestroy(&resultArray);
+
+ // check descending
+ CleanupResetAndDestroyPushL(resultArray);
+ innerQuery = CCaInnerQuery::NewLC();
+ innerQuery->SetSort(CCaInnerQuery::CreatedTimestampDesc);
+ mStorage->GetEntriesL(innerQuery,resultArray);
+ CleanupStack::PopAndDestroy(innerQuery);
+
+ previousTimestamp = 0;
+ for (TInt i = 0; i<resultArray.Count() ; i++) {
+ innerQuery = CCaInnerQuery::NewLC();
+ RArray<TInt> ids;
+ CleanupClosePushL(ids);
+ ids.AppendL(resultArray[i]->GetId());
+ const TInt id = ids[0];
+ innerQuery->SetIdsL(ids);
+
+ TInt64 timestamp(0);
+ CCaSqlQuery *query = CCaSqlQuery::NewLC(STATIC_CAST(CCaSqLiteStorage *,mStorage)->iSqlDb);
+ query->SetQueryL(KSQLGetEntryTimestamp);
+ query->PrepareL();
+ query->BindIdsL(ids, KSQLEntryId);
+ query->ExecuteL(timestamp);
+ if (i != 0 && timestamp > previousTimestamp) {
+ descendingOrderCheckResults[id] = false;
+ break;
+ }
+ previousTimestamp = timestamp;
+ CleanupStack::PopAndDestroy(query);
+ CleanupStack::PopAndDestroy(&ids);
+ CleanupStack::PopAndDestroy(innerQuery);
+ }
+
+ CleanupStack::PopAndDestroy(&resultArray);
+ );
+
+
+ QCOMPARE(err, KErrNone);
+ QCOMPARE(ascendingOrderCheckResults.size(), 0);
+ QCOMPARE(descendingOrderCheckResults.size(), 0);
+ }
+ __UHEAP_MARKEND;
+}
+
+// ---------------------------------------------------------------------------
+// tests getentries sorted by used timestamp.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesSortByMostUsedTimestamp()
+{
+ __UHEAP_MARK;
+
+ const TInt mostUsedIds[3] = {14, 9, 2};
+
+ const TInt mostUsedIdsSize = sizeof(mostUsedIds) / sizeof(TInt);
+
+ TInt err(KErrNone);
+
+ TRAP(err,
+
+ for (TInt i = 0; i < mostUsedIdsSize; ++i) {
+ for (TInt j = mostUsedIdsSize - i; j >= 0; --j) {
+ mStorage->TouchL(mostUsedIds[i], ETrue);
+ }
+ }
+
+ CCaInnerQuery *innerQuery1 = CCaInnerQuery::NewLC();
+ innerQuery1->SetSort(CCaInnerQuery::MostUsedDesc);
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+
+
+ // get entries - most used desscending
+ mStorage->GetEntriesL(innerQuery1, resultArray);
+
+ if (resultArray.Count() < mostUsedIdsSize) {
+ err = KErrNotFound;
+} else {
+ for (TInt i = 0; i < mostUsedIdsSize; ++i) {
+ if (resultArray[i]->GetId() != mostUsedIds[i]) {
+ err = KErrGeneral;
+ break;
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&resultArray);
+ CleanupStack::PopAndDestroy(innerQuery1);
+ );
+
+ QCOMPARE(err, KErrNone);
+
+
+ TRAP(err,
+ CCaInnerQuery *innerQuery1 = CCaInnerQuery::NewLC();
+ innerQuery1->SetSort(CCaInnerQuery::MostUsed);
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+
+
+ // get entries - most used desscending
+ mStorage->GetEntriesL(innerQuery1, resultArray);
+
+ const TInt resultCount = resultArray.Count();
+
+ if (resultCount < mostUsedIdsSize) {
+ err = KErrNotFound;
+} else {
+ for (TInt i = 0; i < mostUsedIdsSize; ++i) {
+ if (resultArray[resultCount - i - 1]->GetId() != mostUsedIds[i]) {
+ err = KErrGeneral;
+ break;
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy(&resultArray);
+ CleanupStack::PopAndDestroy(innerQuery1);
+ );
+ __UHEAP_MARKEND;
+
+
+}
+
+
+// ---------------------------------------------------------------------------
+// tests getentries sorted by used timestamp ascending.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesSortByLastUsedTimestamp()
+{
+ __UHEAP_MARK;
+
+ const TInt lastUsedIds[3] = {14, 9, 2};
+
+ const TInt lastUsedIdsSize = sizeof(lastUsedIds) / sizeof(TInt);
+
+ TInt err(KErrNone);
+
+ TRAP(err,
+
+ for (TInt i = lastUsedIdsSize - 1; i >= 0 ; --i) {
+ mStorage->TouchL(lastUsedIds[i], EFalse);
+ }
+
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ innerQuery->SetSort(CCaInnerQuery::LastUsedDesc);
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+
+
+ // get entries - last used descending
+ mStorage->GetEntriesL(innerQuery, resultArray);
+
+
+ if (resultArray.Count() < lastUsedIdsSize) {
+ err = KErrNotFound;
+} else {
+ for (TInt i = 0; i < lastUsedIdsSize; ++i) {
+ if (resultArray[i]->GetId() != lastUsedIds[i]) {
+ err = KErrGeneral;
+ break;
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&resultArray);
+ CleanupStack::PopAndDestroy(innerQuery);
+ );
+
+
+ QCOMPARE(err, KErrNone);
+
+ TRAP(err,
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ innerQuery->SetSort(CCaInnerQuery::LastUsed);
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+
+
+ // get entries - last used descending
+ mStorage->GetEntriesL(innerQuery, resultArray);
+
+ const TInt resultCount = resultArray.Count();
+
+ if (resultCount < lastUsedIdsSize) {
+ err = KErrNotFound;
+} else {
+ for (TInt i = 0; i < lastUsedIdsSize; ++i) {
+ if (resultArray[resultCount - 1 - i]->GetId() !=
+ lastUsedIds[i]) {
+ err = KErrGeneral;
+ break;
+ }
+ }
+ }
+
+
+ CleanupStack::PopAndDestroy(&resultArray);
+ CleanupStack::PopAndDestroy(innerQuery);
+ );
+
+ __UHEAP_MARKEND;
+}
+
+// ---------------------------------------------------------------------------
+// tests getentries sorted by default ascending.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesSortByDefault()
+{
+
+ __UHEAP_MARK;
+
+ TRAPD(err,
+
+ CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
+ query->SetQueryL(KSQLGetIdEntryFromSpecificGroup);
+ query->PrepareL();
+ query->BindIntL(query->iStatement.ParameterIndex(KSQLGEIdGroup), KAllCollectionsGroupId);
+ RArray<TInt> resultHelpArray;
+ CleanupClosePushL(resultHelpArray);
+ query->ExecuteL(resultHelpArray, CCaSqlQuery::EEntryTable);
+ query->CloseStatement();
+
+ CCaInnerQuery *innerQuery1 = CCaInnerQuery::NewLC();
+ innerQuery1->SetSort(CCaInnerQuery::Default);
+ innerQuery1->SetParentId(KAllCollectionsGroupId);
+
+ CCaInnerQuery *innerQuery2 = CCaInnerQuery::NewLC();
+ innerQuery2->SetSort(CCaInnerQuery::DefaultDesc);
+ innerQuery2->SetParentId(KAllCollectionsGroupId);
+
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+
+ // get entries - bu default from group
+ mStorage->GetEntriesL(innerQuery1, resultArray);
+
+ // check results - compare Entry_Id
+ for (TInt i=0; i<resultArray.Count(); i++) {
+ if (resultArray[i]->GetId() != resultHelpArray[i]) {
+ err = KErrWrongData;
+ }
+ }
+
+ if (!err) {
+ err = testSortingBySortOrder(innerQuery1, innerQuery2);
+ }
+
+ // clear after test
+ CleanupStack::PopAndDestroy(&resultArray);
+ CleanupStack::PopAndDestroy(innerQuery2);
+ CleanupStack::PopAndDestroy(innerQuery1);
+ CleanupStack::PopAndDestroy(&resultHelpArray);
+ CleanupStack::PopAndDestroy(query);
+ );
+
+ __UHEAP_MARKEND;
+
+ QCOMPARE(err, KErrNone);
+}
+
+
+// ---------------------------------------------------------------------------
+// tests getentries sorted by used timestamp ascending.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByFlags()
+{
+
+ __UHEAP_MARK;
+
+ TRAPD(err,
+
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+// test all flags on in KMaxFlagsMask range
+ for (TUint flagsOnMask = 0; flagsOnMask <= KMaxFlagsMask; flagsOnMask++) {
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+ innerQuery->SetFlagsOn(flagsOnMask);
+ mStorage->GetEntriesL(innerQuery,resultArray);
+ TInt entryCount = resultArray.Count();
+ if (entryCount > 0) {
+ for (TInt j = 0; j < entryCount; j++) {
+ if (resultArray[j]->GetFlags() & flagsOnMask != flagsOnMask) {
+ err = KErrWrongData;
+ }
+ }
+ }
+ innerQuery->SetFlagsOn(0);
+ CleanupStack::PopAndDestroy(&resultArray);
+ }
+
+// test all flags off in KMaxFlagsMask range
+ for (TUint flagsOffMask = 0; flagsOffMask <= KMaxFlagsMask; flagsOffMask++) {
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+ innerQuery->SetFlagsOff(flagsOffMask);
+ mStorage->GetEntriesL(innerQuery,resultArray);
+ TInt entryCount = resultArray.Count();
+ if (entryCount > 0) {
+ for (TInt j = 0; j < entryCount; j++) {
+ if ((!resultArray[j]->GetFlags()) & flagsOffMask != flagsOffMask) {
+ err = KErrWrongData;
+ }
+ }
+ }
+ innerQuery->SetFlagsOff(0);
+ CleanupStack::PopAndDestroy(&resultArray);
+ }
+
+// test combination of flags on flags off
+ for (TUint flagsOnMask = 0; flagsOnMask <= KMaxFlagsMaskForCombinedTest; flagsOnMask++) {
+ for (TUint flagsOffMask = 0; flagsOffMask
+ <= KMaxFlagsMaskForCombinedTest; flagsOffMask++) {
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+ innerQuery->SetFlagsOff(flagsOffMask);
+ innerQuery->SetFlagsOn(flagsOnMask);
+ mStorage->GetEntriesL(innerQuery,resultArray);
+ TInt entryCount = resultArray.Count();
+ if (entryCount > 0) {
+ for (TInt j = 0; j < entryCount; j++) {
+ if ((!resultArray[j]->GetFlags()) & flagsOffMask != flagsOffMask
+ && resultArray[j]->GetFlags() & flagsOnMask != flagsOnMask) {
+ err = KErrWrongData;
+ }
+ }
+ }
+ innerQuery->SetFlagsOff(0);
+ innerQuery->SetFlagsOn(0);
+ CleanupStack::PopAndDestroy(&resultArray);
+ }
+ }
+
+ CleanupStack::PopAndDestroy(innerQuery);
+ );
+
+ __UHEAP_MARKEND;
+
+ QCOMPARE(err, KErrNone);
+}
+
+// ---------------------------------------------------------------------------
+// tests getentries with flags which are on
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByFlagsOn()
+{
+
+ __UHEAP_MARK;
+ TRAPD(err,
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ RPointerArray<CCaInnerEntry> resultArrayTemp;
+ CleanupResetAndDestroyPushL(resultArrayTemp);
+ RArray<TInt> testEntries;
+ CleanupClosePushL(testEntries);
+
+ mStorage->GetEntriesL(innerQuery,resultArrayTemp);
+
+ TInt entryCount = resultArrayTemp.Count();
+
+ // Change five random elements' flags
+ err = (entryCount >= 5) ? err : KErrNoData;
+ // Set all flags on to test flags on.
+ for (TInt i = 0; i < entryCount; i++) {
+ resultArrayTemp[i]->SetFlags(0);
+ mStorage->AddL(resultArrayTemp[i]);
+ }
+
+ // get random entries to test on
+ TInt testIdCount(0);
+ while (testEntries.Count() < 5) {
+ TInt randomEntryInArray = Math::Random() % entryCount;
+ TBool exists(EFalse);
+ for (TInt i = 0; i < testEntries.Count(); i++) {
+ if (testEntries[i]== randomEntryInArray) {
+ exists = ETrue;
+ break;
+ }
+ }
+ if (!exists) {
+ testEntries.AppendL(randomEntryInArray);
+ }
+ }
+
+ // test flags on with flags from KFlagsOnTable
+
+ CCaInnerQuery *innerQueryFlagsOn = CCaInnerQuery::NewLC();
+ for (TInt j = 0; j < 5; j++) {
+ // fill database with flag
+ for (TInt i = 0; i < 5; i++) {
+ TInt x = testEntries[i];
+ resultArrayTemp[x]->SetFlags(KFlagsOnTable[j]);
+ mStorage->AddL(resultArrayTemp[x]);
+ }
+
+ // check filled database
+ RPointerArray<CCaInnerEntry> resultArrayFlagsOn;
+ CleanupResetAndDestroyPushL(resultArrayFlagsOn);
+ innerQueryFlagsOn->SetFlagsOn(KFlagsOnTable[j]);
+ mStorage->GetEntriesL(innerQueryFlagsOn,resultArrayFlagsOn);
+ TInt count = resultArrayFlagsOn.Count();
+ err = (resultArrayFlagsOn.Count() >= 5) ? err : KErrWrongData;
+
+ // check that the right entries were fetched
+ for (TInt i = 0; i < 5; i++) {
+ for (TInt j = 0; j < resultArrayFlagsOn.Count(); j++) {
+ if (resultArrayFlagsOn[j]->GetId() ==
+ resultArrayTemp[testEntries[i]]->GetId()) {
+ break;
+ } else if (j == resultArrayFlagsOn.Count()-1) {
+ err = KErrWrongData;
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&resultArrayFlagsOn);
+ }
+ CleanupStack::PopAndDestroy(innerQueryFlagsOn);
+ CleanupStack::PopAndDestroy(&testEntries);
+ CleanupStack::PopAndDestroy(&resultArrayTemp);
+ CleanupStack::PopAndDestroy(innerQuery);
+ );
+ __UHEAP_MARKEND;
+
+ QCOMPARE(err, KErrNone);
+}
+
+
+// ---------------------------------------------------------------------------
+// tests getentries with flags which are off
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByFlagsOff()
+{
+ __UHEAP_MARK;
+ TRAPD(err,
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ RPointerArray<CCaInnerEntry> resultArrayTemp;
+ CleanupResetAndDestroyPushL(resultArrayTemp);
+ RArray<TInt> testEntries;
+ CleanupClosePushL(testEntries);
+
+ mStorage->GetEntriesL(innerQuery,resultArrayTemp);
+
+ TInt entryCount = resultArrayTemp.Count();
+
+ // Change five random elements' flags
+ err = (entryCount >= 5) ? err : KErrNoData;
+ // Set all flags off to test flags off assuming that there are 5 flags (63 bitwise)
+ for (TInt i = 0; i < entryCount; i++) {
+ resultArrayTemp[i]->SetFlags(63);
+ mStorage->AddL(resultArrayTemp[i]);
+ }
+
+ // get random entries to test on
+ TInt testIdCount(0);
+ while (testEntries.Count() < 5) {
+ TInt randomEntryInArray = Math::Random() % entryCount;
+ TBool exists(EFalse);
+ for (TInt i = 0; i < testEntries.Count(); i++) {
+ if (testEntries[i]== randomEntryInArray) {
+ exists = ETrue;
+ break;
+ }
+ }
+ if (!exists) {
+ testEntries.AppendL(randomEntryInArray);
+ }
+ }
+
+ // test flags on with flags from KFlagsOffTable
+
+ CCaInnerQuery *innerQueryFlagsOff = CCaInnerQuery::NewLC();
+ for (TInt j = 0; j < 5; j++) {
+ // fill database with flag
+ for (TInt i = 0; i < 5; i++) {
+ TInt x = testEntries[i];
+ resultArrayTemp[x]->SetFlags(KFlagsOffTable[j]);
+ mStorage->AddL(resultArrayTemp[x]);
+ }
+
+ // check filled database
+ RPointerArray<CCaInnerEntry> resultArrayFlagsOff;
+ CleanupResetAndDestroyPushL(resultArrayFlagsOff);
+ innerQueryFlagsOff->SetFlagsOff(KFlagsOffTableMasks[j]);
+ mStorage->GetEntriesL(innerQueryFlagsOff,resultArrayFlagsOff);
+ TInt count = resultArrayFlagsOff.Count();
+ err = (resultArrayFlagsOff.Count() >= 5) ? err : KErrWrongData;
+
+ // check that the right entries were fetched
+ for (TInt i = 0; i < 5; i++) {
+ for (TInt j = 0; j < resultArrayFlagsOff.Count(); j++) {
+ if (resultArrayFlagsOff[j]->GetId() ==
+ resultArrayTemp[testEntries[i]]->GetId()) {
+ break;
+ } else if (j == resultArrayFlagsOff.Count()-1) {
+ err = KErrWrongData;
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&resultArrayFlagsOff);
+ }
+ CleanupStack::PopAndDestroy(innerQueryFlagsOff);
+ CleanupStack::PopAndDestroy(&testEntries);
+ CleanupStack::PopAndDestroy(&resultArrayTemp);
+ CleanupStack::PopAndDestroy(innerQuery);
+ );
+ __UHEAP_MARKEND;
+ QCOMPARE(err, KErrNone);
+}
+
+
+// ---------------------------------------------------------------------------
+// tests getentries by uid.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByUid()
+{
+ __UHEAP_MARK;
+ TRAPD(err,
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ innerQuery->SetUid(KCalendarAppUid);
+
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+
+ mStorage->GetEntriesL(innerQuery,resultArray);
+
+ TInt entryCount = resultArray.Count();
+
+ err = (entryCount == 1 && resultArray[0]->GetUid() == KCalendarAppUid)
+ ? err : KErrWrongData;
+
+ CleanupStack::PopAndDestroy(&resultArray);
+ CleanupStack::PopAndDestroy(innerQuery);
+ );
+ __UHEAP_MARKEND;
+
+ QCOMPARE(err, KErrNone);
+}
+
+// ---------------------------------------------------------------------------
+// tests getentries by uid.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesIds()
+{
+ __UHEAP_MARK;
+
+ TRAPD(err,
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ RArray<TInt> idArray;
+ CleanupClosePushL(idArray);
+
+ mStorage->GetEntriesIdsL(innerQuery,idArray);
+
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+
+ mStorage->GetEntriesL(innerQuery,resultArray);
+
+ err = (idArray.Count() > 0) ? err : KErrNoData;
+ if (!err) {
+ err = (idArray.Count() == resultArray.Count()) ? err : KErrWrongData;
+ }
+
+ CleanupStack::PopAndDestroy(&resultArray);
+ CleanupStack::PopAndDestroy(&idArray);
+ CleanupStack::PopAndDestroy(innerQuery);
+ );
+ __UHEAP_MARKEND;
+
+ QCOMPARE(err, KErrNone);
+}
+
+// ---------------------------------------------------------------------------
+//
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetNewEntryWithAttributes()
+{
+ __UHEAP_MARK;
+ TInt err(KErrGeneral);
+ TRAP(err,
+ // Check database entries count
+ CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
+ query->SetQueryL(KSQLGetIdCountFromEntryTable);
+ query->PrepareL();
+ TInt entriesCount(0);
+ query->ExecuteL(entriesCount);
+ CleanupStack::PopAndDestroy(query);
+
+
+ // add new entry with attributes
+ CCaInnerEntry *innerEntry = CCaInnerEntry::NewL();
+ RPointerArray<CCaInnerEntry> innerEntryArray;
+ CleanupResetAndDestroyPushL(innerEntryArray);
+ innerEntryArray.AppendL(innerEntry);
+
+ innerEntry->SetTextL(KTestName);
+ innerEntry->SetEntryTypeNameL(KTypeName);
+ innerEntry->SetFlags(flag);
+ innerEntry->SetRole(CCaInnerQuery::Item);
+ innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
+
+ innerEntry->AddAttributeL(KAttrName_1, KAttrValue_1);
+ innerEntry->AddAttributeL(KAttrName_2, KAttrValue_2);
+ innerEntry->AddAttributeL(KAttrName_3, KAttrValue_3);
+
+ mStorage->AddL(innerEntry);
+ CleanupStack::PopAndDestroy(&innerEntryArray);
+
+
+ // get new entry with attributes
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+ RArray<TInt> idArray;
+ CleanupClosePushL(idArray);
+ idArray.AppendL(entriesCount + 1); // new entry
+
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ innerQuery->SetIdsL(idArray);
+
+ mStorage->GetEntriesL(innerQuery, resultArray);
+
+ // check results
+ TInt attributesCount = resultArray[0]->GetAttributes().Count();
+
+ if (attributesCount == 3) {
+ err = KErrNone;
+} else {
+ err = KErrGeneral;
+}
+
+// clear after test
+CleanupStack::PopAndDestroy(innerQuery);
+CleanupStack::PopAndDestroy(&idArray);
+CleanupStack::PopAndDestroy(&resultArray);
+ );
+
+ __UHEAP_MARKEND;
+
+ QCOMPARE(err, KErrNone);
+}
+
+// ---------------------------------------------------------------------------
+//
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetNewEntryWithAttributesByUid()
+{
+ __UHEAP_MARK;
+
+ TInt err(KErrGeneral);
+
+ TRAP(err,
+ // add new entry with attributes
+ CCaInnerEntry *innerEntry = CCaInnerEntry::NewL();
+ RPointerArray<CCaInnerEntry> innerEntryArray;
+ CleanupResetAndDestroyPushL(innerEntryArray);
+ innerEntryArray.AppendL(innerEntry);
+
+ innerEntry->SetTextL(KTestName);
+ innerEntry->SetEntryTypeNameL(KTypeName2);
+ innerEntry->SetFlags(flag);
+ innerEntry->SetRole(CCaInnerQuery::Item);
+ innerEntry->SetUid(KTestAppUid);
+ innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
+
+ innerEntry->AddAttributeL(KAttrName_1, KAttrValue_1);
+ innerEntry->AddAttributeL(KAttrName_2, KAttrValue_2);
+ innerEntry->AddAttributeL(KAttrName_3, KAttrValue_3);
+
+ mStorage->AddL(innerEntry);
+ CleanupStack::PopAndDestroy(&innerEntryArray);
+
+
+ // get new entry with attributes by uid
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ innerQuery->SetUid(KTestAppUid);
+
+ mStorage->GetEntriesL(innerQuery, resultArray);
+
+ // check results
+ TInt attributesCount = resultArray[0]->GetAttributes().Count();
+
+ if (attributesCount == 3) {
+ err = KErrNone;
+} else {
+ err = KErrGeneral;
+}
+
+// clear after test
+CleanupStack::PopAndDestroy(innerQuery);
+CleanupStack::PopAndDestroy(&resultArray);
+ );
+ __UHEAP_MARKEND;
+
+ QCOMPARE(err, KErrNone);
+}
+
+// ---------------------------------------------------------------------------
+// Test Select entries with limit.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesWhenLimitSetTo()
+{
+
+
+ QList<int> entryCountList;
+ entryCountList << 5 << -15 << 0 << 50;
+ __UHEAP_MARK;
+
+ int limit(0);
+ foreach(limit, entryCountList) {
+ // Check database entries count
+ TRAPD(err,
+ CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
+ query->SetQueryL(KSQLGetIdCountFromEntryTable);
+ query->PrepareL();
+ TInt entriesCount(0);
+ query->ExecuteL(entriesCount);
+ CleanupStack::PopAndDestroy(query);
+
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+
+ innerQuery->SetCount(limit);
+
+ // limit is set to stif parser param
+ mStorage->GetEntriesL(innerQuery, resultArray);
+
+
+ // check results
+ if ((0 < limit) && (limit <= entriesCount)) {
+ if (resultArray.Count() == innerQuery->GetCount()) {
+ err = KErrNone;
+ } else {
+ err = KErrGeneral;
+ }
+ } else {
+ if (resultArray.Count() == entriesCount) {
+ err = KErrNone;
+ } else {
+ err = KErrGeneral;
+ }
+ }
+
+ // clear after test
+ CleanupStack::PopAndDestroy(innerQuery);
+ CleanupStack::PopAndDestroy(&resultArray);
+ );
+ // limit added to make easier to identify where failure occured
+ QCOMPARE(err + limit, KErrNone + limit);
+ }
+ __UHEAP_MARKEND;
+}
+
+// ---------------------------------------------------------------------------
+// Test Select entries by role.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByRole()
+{
+
+
+ __UHEAP_MARK;
+ TRAPD(err,
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+
+ RPointerArray<CCaInnerEntry> resultArrayGroups;
+ CleanupResetAndDestroyPushL(resultArrayGroups);
+ innerQuery->SetRole(CCaInnerQuery::Group);
+ mStorage->GetEntriesL(innerQuery, resultArrayGroups);
+ TInt groupsCount = resultArrayGroups.Count();
+ CleanupStack::PopAndDestroy(&resultArrayGroups);
+
+ RPointerArray<CCaInnerEntry> resultArrayItems;
+ CleanupResetAndDestroyPushL(resultArrayItems);
+ innerQuery->SetRole(CCaInnerQuery::Item);
+ mStorage->GetEntriesL(innerQuery, resultArrayItems);
+ TInt itemsCount = resultArrayItems.Count();
+// changes the role of two items to be groups
+
+ resultArrayItems[0]->SetRole(CCaInnerQuery::Group);
+ resultArrayItems[1]->SetRole(CCaInnerQuery::Group);
+ TInt entry1Id = resultArrayItems[0]->GetId();
+ TInt entry2Id = resultArrayItems[1]->GetId();
+ mStorage->AddL(resultArrayItems[0]);
+ mStorage->AddL(resultArrayItems[1]);
+ CleanupStack::PopAndDestroy(&resultArrayItems);
+
+ RPointerArray<CCaInnerEntry> resultArrayGroups2;
+ CleanupResetAndDestroyPushL(resultArrayGroups2);
+ innerQuery->SetRole(CCaInnerQuery::Group);
+ mStorage->GetEntriesL(innerQuery, resultArrayGroups2);
+ TInt groupsCountAfterModifyRole = resultArrayGroups2.Count();
+ err = (groupsCountAfterModifyRole == groupsCount + 2)? err : KErrWrongData;
+
+// Check that entry 1 is now group
+ for (TInt i = 0; i < groupsCountAfterModifyRole; i++) {
+ if (resultArrayGroups2[i]->GetId() == entry1Id) {
+ break;
+ } else if (i == groupsCountAfterModifyRole - 1) {
+ err = KErrWrongData;
+ }
+ }
+
+// Check that entry 2 is now group
+ for (TInt i = 0; i < groupsCountAfterModifyRole; i++) {
+ if (resultArrayGroups2[i]->GetId() == entry2Id) {
+ break;
+ } else if (i == groupsCountAfterModifyRole - 1) {
+ err = KErrWrongData;
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&resultArrayGroups2);
+
+ RPointerArray<CCaInnerEntry> resultArrayItems2;
+ CleanupResetAndDestroyPushL(resultArrayItems2);
+ innerQuery->SetRole(CCaInnerQuery::Item);
+ mStorage->GetEntriesL(innerQuery, resultArrayItems2);
+ TInt itemsCountAfterModifyRole = resultArrayItems2.Count();
+ err = (itemsCountAfterModifyRole == itemsCount - 2)? err : KErrWrongData;
+ CleanupStack::PopAndDestroy(&resultArrayItems2);
+
+ CleanupStack::PopAndDestroy(innerQuery);
+ );
+ __UHEAP_MARKEND;
+
+ QCOMPARE(err, KErrNone);
+}
+
+void CCAStorageTest::testGetEntriesByAttributes()
+{
+ __UHEAP_MARK;
+ int uid;
+ TInt attributesCount;
+ TInt attributesCountFromQuery;
+ TRAPD(err,
+
+ // add new entry with attributes
+ CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
+
+ innerEntry->SetTextL(KTestName);
+ innerEntry->SetEntryTypeNameL(KTypeName2);
+ innerEntry->SetFlags(flag);
+ innerEntry->SetRole(CCaInnerQuery::Item);
+ innerEntry->SetUid(KTestAppUid);
+ innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
+
+ innerEntry->AddAttributeL(KAttrName_1, KAttrValue_1);
+ innerEntry->AddAttributeL(KAttrName_2, KAttrValue_2);
+ innerEntry->AddAttributeL(KAttrName_3, KAttrValue_3);
+
+ mStorage->AddL(innerEntry);
+
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ innerQuery->AddAttributeL(KAttrName_2, KAttrValue_2);
+ innerQuery->AddAttributeL(KAttrName_3, KAttrValue_3);
+ attributesCountFromQuery = innerQuery->GetAttributes().Count();
+
+ // get entries by attributes
+ RPointerArray<CCaInnerEntry> resultArrayItems;
+ CleanupResetAndDestroyPushL(resultArrayItems);
+ mStorage->GetEntriesL(innerQuery, resultArrayItems);
+
+ if( resultArrayItems.Count() )
+ {
+ uid = resultArrayItems[0]->GetUid();
+ attributesCount = resultArrayItems[0]->GetAttributes().Count();
+ }
+
+ CleanupStack::PopAndDestroy(&resultArrayItems);
+ CleanupStack::PopAndDestroy(innerQuery);
+ CleanupStack::PopAndDestroy(innerEntry);
+ );
+ __UHEAP_MARKEND;
+
+ QCOMPARE(uid, KTestAppUid);
+ QCOMPARE((attributesCount-1), attributesCountFromQuery);
+ QCOMPARE(err, KErrNone);
+}
+
+void CCAStorageTest::testGetEntriesByAttributes2()
+{
+ __UHEAP_MARK;
+ int getEntriesCount;
+ TRAPD(err,
+
+ // add new entry with attributes
+ CCaInnerEntry *innerEntry = CCaInnerEntry::NewLC();
+
+ innerEntry->SetTextL(KTestName);
+ innerEntry->SetEntryTypeNameL(KTypeName2);
+ innerEntry->SetFlags(flag);
+ innerEntry->SetRole(CCaInnerQuery::Item);
+ innerEntry->SetUid(KTestAppUid);
+ innerEntry->SetIconDataL(_L("filename"), _L("skinId"), _L("268458321"));
+
+ innerEntry->AddAttributeL(KAttrName_1, KAttrValue_1);
+ innerEntry->AddAttributeL(KAttrName_2, KAttrValue_2);
+ innerEntry->AddAttributeL(KAttrName_3, KAttrValue_3);
+
+ mStorage->AddL(innerEntry);
+
+ // add new entry with attributes
+ CCaInnerEntry *innerEntry2 = CCaInnerEntry::NewLC();
+
+ innerEntry2->SetTextL(KTestName2);
+ innerEntry2->SetEntryTypeNameL(KTypeName2);
+ innerEntry2->SetFlags(flag);
+ innerEntry2->SetRole(CCaInnerQuery::Item);
+ innerEntry2->SetUid(KTestAppUid2);
+
+ // add new entry with attributes
+ innerEntry2->AddAttributeL(KAttrName_1, KAttrValue_1);
+ innerEntry2->AddAttributeL(KAttrName_2, KAttrValue_2);
+
+ mStorage->AddL(innerEntry2);
+
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+ innerQuery->AddAttributeL(KAttrName_1, KAttrValue_1);
+ innerQuery->AddAttributeL(KAttrName_2, KAttrValue_2);
+
+ // get entries by attributes
+ RPointerArray<CCaInnerEntry> resultArrayItems;
+ CleanupResetAndDestroyPushL(resultArrayItems);
+ mStorage->GetEntriesL(innerQuery, resultArrayItems);
+
+ TInt attributesCount = resultArrayItems[0]->GetAttributes().Count();
+ getEntriesCount = resultArrayItems.Count();
+
+ CleanupStack::PopAndDestroy(&resultArrayItems);
+ CleanupStack::PopAndDestroy(innerQuery);
+ CleanupStack::PopAndDestroy(innerEntry2);
+ CleanupStack::PopAndDestroy(innerEntry);
+ );
+ __UHEAP_MARKEND;
+
+ QCOMPARE(getEntriesCount, 2);
+ QCOMPARE(err, KErrNone);
+}
+
+// ---------------------------------------------------------------------------
+// Test Select entries by child id.
+//
+// ---------------------------------------------------------------------------
+//
+void CCAStorageTest::testGetEntriesByChildId()
+{
+ TInt expectedGroupEntryCount(0);
+ TInt actualGroupEntryCount(0);
+
+ __UHEAP_MARK;
+
+ TRAPD(err,
+ CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
+
+ // check before test entries count in sfecific group
+ CCaSqlQuery *query = CCaSqlQuery::NewLC(((CCaSqLiteStorage *)mStorage)->iSqlDb);
+ query->SetQueryL(KSQLGetEntriesCountAsParentsForSpecificEntry);
+ query->PrepareL();
+ query->BindIntL(query->iStatement.ParameterIndex(KSQLGEEntryId), 7);
+
+ query->ExecuteL(expectedGroupEntryCount);
+
+ CleanupStack::PopAndDestroy(query);
+
+ innerQuery->SetChildId(7);
+
+ // get entries from specific group
+ RPointerArray<CCaInnerEntry> resultArray;
+ CleanupResetAndDestroyPushL(resultArray);
+
+ mStorage->GetEntriesL(innerQuery, resultArray);
+
+ actualGroupEntryCount = resultArray.Count();
+
+ CleanupStack::PopAndDestroy(&resultArray);
+ CleanupStack::PopAndDestroy(innerQuery);
+ );
+
+ __UHEAP_MARKEND;
+
+ QCOMPARE(err, KErrNone);
+ QCOMPARE(actualGroupEntryCount, expectedGroupEntryCount);
+}
+