Mercurial Mercurial > oss > FCL > sf > app > recents / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
logsui/logsapp/tsrc/ut_logsapp/src/ut_logsrecentcallsview.cpp
changeset 16 c5af8598d22c
parent 14 f27aebe284bb
child 19 e4c884866116
equal deleted inserted replaced
14:f27aebe284bb 16:c5af8598d22c 
    40 #include <hblistviewitem.h>
 
    40 #include <hblistviewitem.h>
 
    41 #include <hbmenu.h>
 
    41 #include <hbmenu.h>
 
    42 #include <dialpad.h>
 
    42 #include <dialpad.h>
 
    43 #include <hbgroupbox.h>
 
    43 #include <hbgroupbox.h>
 
    44 #include <hbmessagebox.h>
 
    44 #include <hbmessagebox.h>
 
    45 
    45 #include <xqaiwdecl.h>
 
    46 
    46 
    47 #define VERIFY_CHECKED_ACTION( v, actionName ) { \
 
    47 #define VERIFY_CHECKED_ACTION( v, actionName ) { \
 
    48 QVERIFY( v->mShowFilterMenu );\
 
    48 QVERIFY( v->mShowFilterMenu );\
 
    49 QVERIFY( v->mShowFilterMenu->actions().count() > 0 );\
 
    49 QVERIFY( v->mShowFilterMenu->actions().count() > 0 );\
 
    50 QAction* action = 0;\
 
    50 QAction* action = 0;\
 
    89     QVERIFY( !mRecentCallsView->mViewName );
 
    89     QVERIFY( !mRecentCallsView->mViewName );
 
    90     QVERIFY( !mRecentCallsView->mListView );
 
    90     QVERIFY( !mRecentCallsView->mListView );
 
    91     QVERIFY( !mRecentCallsView->mFilter );
 
    91     QVERIFY( !mRecentCallsView->mFilter );
 
    92     QVERIFY( mRecentCallsView->mModel );
 
    92     QVERIFY( mRecentCallsView->mModel );
 
    93     QVERIFY( !mRecentCallsView->mShowFilterMenu );
 
    93     QVERIFY( !mRecentCallsView->mShowFilterMenu );
 
    94     QVERIFY( mRecentCallsView->mCurrentView == LogsServices::ViewAll );
 
    94     QVERIFY( mRecentCallsView->mCurrentView == XQService::LogsViewAll );
 
    95     QVERIFY( mRecentCallsView->viewId() == LogsRecentViewId );
 
    95     QVERIFY( mRecentCallsView->viewId() == LogsRecentViewId );
 
    96     QVERIFY( mRecentCallsView->mLayoutSectionName == "" );
 
    96     QVERIFY( mRecentCallsView->mLayoutSectionName == "" );
 
    97     QCOMPARE( mRecentCallsView->mActivities.at(LogsServices::ViewAll), QString(logsActivityIdViewRecent) );
 
    97     QCOMPARE( mRecentCallsView->mActivities.at(XQService::LogsViewAll), QString(logsActivityIdViewRecent) );
 
    98     QCOMPARE( mRecentCallsView->mActivities.at(LogsServices::ViewReceived), QString(logsActivityIdViewReceived) );
 
    98     QCOMPARE( mRecentCallsView->mActivities.at(XQService::LogsViewReceived), QString(logsActivityIdViewReceived) );
 
    99     QCOMPARE( mRecentCallsView->mActivities.at(LogsServices::ViewCalled), QString(logsActivityIdViewCalled) );
 
    99     QCOMPARE( mRecentCallsView->mActivities.at(XQService::LogsViewCalled), QString(logsActivityIdViewCalled) );
 
   100     QCOMPARE( mRecentCallsView->mActivities.at(LogsServices::ViewMissed), QString(logsActivityIdViewMissed) );
 
   100     QCOMPARE( mRecentCallsView->mActivities.at(XQService::LogsViewMissed), QString(logsActivityIdViewMissed) );
 
   101     
   101     
   102 }
 
   102 }
 
   103 
   103 
   104 void UT_LogsRecentCallsView::testInitView()
 
   104 void UT_LogsRecentCallsView::testInitView()
 
   105 {
 
   105 {
 
   126     QVERIFY( view );
 
   126     QVERIFY( view );
 
   127     // Change for uninitialized causes initialization
 
   127     // Change for uninitialized causes initialization
 
   128     QVERIFY( !view->mInitialized );
 
   128     QVERIFY( !view->mInitialized );
 
   129     QVERIFY( !view->mFilter );
 
   129     QVERIFY( !view->mFilter );
 
   130     QVERIFY( !view->mEmptyListLabel );
 
   130     QVERIFY( !view->mEmptyListLabel );
 
   131     view->activated(false, QVariant(LogsServices::ViewAll));
 
   131     view->activated(false, QVariant(XQService::LogsViewAll));
 
   132     QVERIFY( view->mInitialized );
 
   132     QVERIFY( view->mInitialized );
 
   133     QVERIFY( view->mFilter );
 
   133     QVERIFY( view->mFilter );
 
   134     QVERIFY( view->mEmptyListLabel );
 
   134     QVERIFY( view->mEmptyListLabel );
 
   135     VERIFY_CHECKED_ACTION( view, logsShowFilterRecentMenuActionId )
 
   135     VERIFY_CHECKED_ACTION( view, logsShowFilterRecentMenuActionId )
 
   136     
   136     
   137     // Change views
 
   137     // Change views
 
   138     view->activated(false, QVariant(LogsServices::ViewReceived));
 
   138     view->activated(false, QVariant(XQService::LogsViewReceived));
 
   139     QVERIFY( view->mFilter );
 
   139     QVERIFY( view->mFilter );
 
   140     QVERIFY( view->mFilter->filterType() == LogsFilter::Received );  
   140     QVERIFY( view->mFilter->filterType() == LogsFilter::Received );  
   141     VERIFY_CHECKED_ACTION( view, logsShowFilterReceivedMenuActionId )
 
   141     VERIFY_CHECKED_ACTION( view, logsShowFilterReceivedMenuActionId )
 
   142     
   142     
   143     view->activated(false, QVariant(LogsServices::ViewMissed));
 
   143     view->activated(false, QVariant(XQService::LogsViewMissed));
 
   144     QVERIFY( view->mFilter->filterType() == LogsFilter::Missed );  
   144     QVERIFY( view->mFilter->filterType() == LogsFilter::Missed );  
   145     VERIFY_CHECKED_ACTION( view, logsShowFilterMissedMenuActionId )
 
   145     VERIFY_CHECKED_ACTION( view, logsShowFilterMissedMenuActionId )
 
   146     
   146     
   147     view->activated(false, QVariant(LogsServices::ViewCalled));
 
   147     view->activated(false, QVariant(XQService::LogsViewCalled));
 
   148     QVERIFY( view->mFilter->filterType() == LogsFilter::Called );  
   148     QVERIFY( view->mFilter->filterType() == LogsFilter::Called );  
   149     VERIFY_CHECKED_ACTION( view, logsShowFilterDialledMenuActionId )
 
   149     VERIFY_CHECKED_ACTION( view, logsShowFilterDialledMenuActionId )
 
   150     
   150     
   151     view->mViewManager.mainWindow().setOrientation( Qt::Horizontal );
 
   151     view->mViewManager.mainWindow().setOrientation( Qt::Horizontal );
 
   152     view->mDialpad->editor().setText( QString("hello") );
 
   152     view->mDialpad->editor().setText( QString("hello") );
 
   153     view->mFirstActivation = true;
 
   153     view->mActivating = true;
 
   154     view->activated(false, QVariant(LogsServices::ViewAll));
 
   154     view->activated(false, QVariant(XQService::LogsViewAll));
 
   155     QVERIFY( view->mFilter->filterType() == LogsFilter::All );  
   155     QVERIFY( view->mFilter->filterType() == LogsFilter::All );  
   156     VERIFY_CHECKED_ACTION( view, logsShowFilterRecentMenuActionId )
 
   156     VERIFY_CHECKED_ACTION( view, logsShowFilterRecentMenuActionId )
 
   157     QVERIFY( !view->mDialpad->editor().text().isEmpty() );
 
   157     QVERIFY( !view->mDialpad->editor().text().isEmpty() );
 
   158     QVERIFY( view->mListView->layoutName() == logsListLandscapeLayout );
 
   158     QVERIFY( view->mListView->layoutName() == logsListLandscapeLayout );
 
   159     QVERIFY( view->mLayoutSectionName == logsViewDefaultSection );
 
   159     QVERIFY( view->mLayoutSectionName == logsViewDefaultSection );
 
   160     QVERIFY( !view->mFirstActivation );
 
   160     QVERIFY( !view->mActivating );
 
   161 }
 
   161 }
 
   162 
   162 
   163 void UT_LogsRecentCallsView::testDeactivated()
 
   163 void UT_LogsRecentCallsView::testDeactivated()
 
   164 {
 
   164 {
 
   165     mRecentCallsView->deactivated();
 
   165     mRecentCallsView->deactivated();
 
   199     QVERIFY( !HbStubHelper::singleShotTimerActive() );
 
   199     QVERIFY( !HbStubHelper::singleShotTimerActive() );
 
   200     delete mRecentCallsView->mListView;
 
   200     delete mRecentCallsView->mListView;
 
   201     mRecentCallsView->mListView = 0;
 
   201     mRecentCallsView->mListView = 0;
 
   202             
   202             
   203     //filter is updated with a new one, missed calls marking as seen is started (by timer)
 
   203     //filter is updated with a new one, missed calls marking as seen is started (by timer)
 
   204     mRecentCallsView->mFirstActivation = false;
 
   204     mRecentCallsView->mActivating = false;
 
   205     QVERIFY( mRecentCallsView->mFilter );
 
   205     QVERIFY( mRecentCallsView->mFilter );
 
   206     mRecentCallsView->mListView = new HbListView();
 
   206     mRecentCallsView->mListView = new HbListView();
 
   207     mRecentCallsView->updateFilter(LogsFilter::Missed);
 
   207     mRecentCallsView->updateFilter(LogsFilter::Missed);
 
   208     QVERIFY( mRecentCallsView->mFilter );
 
   208     QVERIFY( mRecentCallsView->mFilter );
 
   209     QVERIFY( mRecentCallsView->mFilter->filterType() == LogsFilter::Missed );
 
   209     QVERIFY( mRecentCallsView->mFilter->filterType() == LogsFilter::Missed );
 
   210     QVERIFY( HbStubHelper::singleShotTimerActive() );
 
   210     QVERIFY( HbStubHelper::singleShotTimerActive() );
 
   211     delete mRecentCallsView->mListView;
 
   211     delete mRecentCallsView->mListView;
 
   212     mRecentCallsView->mListView = 0;
 
   212     mRecentCallsView->mListView = 0;
 
   213     
   213     
   214     //filter is updated with a new one, missed calls marking as seen is not started
 
   214     //filter is updated with a new one, missed calls marking as seen is not started
 
   215     //as this is first view activation
 
   215     //as view activation is ongoing
 
   216     HbStubHelper::reset();
 
   216     HbStubHelper::reset();
 
   217     mRecentCallsView->mFirstActivation = true;
 
   217     mRecentCallsView->mActivating = true;
 
   218     mRecentCallsView->mListView = new HbListView();
 
   218     mRecentCallsView->mListView = new HbListView();
 
   219     mRecentCallsView->updateFilter(LogsFilter::Missed);
 
   219     mRecentCallsView->updateFilter(LogsFilter::Missed);
 
   220     QVERIFY( mRecentCallsView->mFilter );
 
   220     QVERIFY( mRecentCallsView->mFilter );
 
   221     QVERIFY( mRecentCallsView->mFilter->filterType() == LogsFilter::Missed );
 
   221     QVERIFY( mRecentCallsView->mFilter->filterType() == LogsFilter::Missed );
 
   222     QVERIFY( !HbStubHelper::singleShotTimerActive() );
 
   222     QVERIFY( !HbStubHelper::singleShotTimerActive() );
 
   228     QVERIFY( !mRecentCallsView->mViewName );
 
   228     QVERIFY( !mRecentCallsView->mViewName );
 
   229     mRecentCallsView->updateViewName();
 
   229     mRecentCallsView->updateViewName();
 
   230     QVERIFY( !mRecentCallsView->mViewName );
 
   230     QVERIFY( !mRecentCallsView->mViewName );
 
   231     
   231     
   232     //view name label exists
 
   232     //view name label exists
 
   233     mRecentCallsView->mCurrentView = LogsServices::ViewMissed;
 
   233     mRecentCallsView->mCurrentView = XQService::LogsViewMissed;
 
   234     mRecentCallsView->addStringsToMap();
 
   234     mRecentCallsView->addStringsToMap();
 
   235     mRecentCallsView->mViewName = new HbGroupBox();
 
   235     mRecentCallsView->mViewName = new HbGroupBox();
 
   236     mRecentCallsView->updateViewName();
 
   236     mRecentCallsView->updateViewName();
 
   237     QVERIFY( mRecentCallsView->mViewName->heading() 
   237     QVERIFY( mRecentCallsView->mViewName->heading() 
   238             == mRecentCallsView->mTitleMap.value(
 
   238             == mRecentCallsView->mTitleMap.value(
 
   239                    mRecentCallsView->mConversionMap.value(LogsServices::ViewMissed)));
 
   239                    mRecentCallsView->mConversionMap.value(XQService::LogsViewMissed)));
 
   240     delete mRecentCallsView->mViewName;
 
   240     delete mRecentCallsView->mViewName;
 
   241     mRecentCallsView->mViewName = 0;
 
   241     mRecentCallsView->mViewName = 0;
 
   242 }
 
   242 }
 
   243 
   243 
   244 void UT_LogsRecentCallsView::testChangeFilter()
 
   244 void UT_LogsRecentCallsView::testChangeFilter()
 
   245 {
 
   245 {
 
   246     mRepository->recentCallsView();
 
   246     mRepository->recentCallsView();
 
   247     mRecentCallsView->activated( false, QVariant(LogsServices::ViewAll) );
 
   247     mRecentCallsView->activated( false, QVariant(XQService::LogsViewAll) );
 
   248     QVERIFY( mRecentCallsView->mFilter );
 
   248     QVERIFY( mRecentCallsView->mFilter );
 
   249     QVERIFY( mRecentCallsView->mFilter->filterType() == LogsFilter::All );
 
   249     QVERIFY( mRecentCallsView->mFilter->filterType() == LogsFilter::All );
 
   250     
   250     
   251     HbAction*  action = new HbAction();
 
   251     HbAction*  action = new HbAction();
 
   252     action->setObjectName(logsShowFilterMissedMenuActionId);
 
   252     action->setObjectName(logsShowFilterMissedMenuActionId);
 
   253     mRecentCallsView->changeFilter(action);
 
   253     mRecentCallsView->changeFilter(action);
 
   254     // Scrollbar is disbaled while changing the list and is restored when appearByMoving slot is called
 
   254     // Scrollbar is disbaled while changing the list and is restored when appearByMoving slot is called
 
   255     QVERIFY( mRecentCallsView->mListView->verticalScrollBarPolicy() == HbScrollArea::ScrollBarAlwaysOff );
 
   255     QVERIFY( mRecentCallsView->mListView->verticalScrollBarPolicy() == HbScrollArea::ScrollBarAlwaysOff );
 
   256     
   256     
   257     // Because of effects, filter is not changed immediately, simulate effect completion
 
   257     // Because of effects, filter is not changed immediately, simulate effect completion
 
   258     QVERIFY( mRecentCallsView->mAppearingView == LogsServices::ViewMissed );
 
   258     QVERIFY( mRecentCallsView->mAppearingView == XQService::LogsViewMissed );
 
   259     mRecentCallsView->dissappearByMovingComplete();
 
   259     mRecentCallsView->dissappearByMovingComplete();
 
   260     QVERIFY( mRecentCallsView->mFilter->filterType() == LogsFilter::Missed );   
   260     QVERIFY( mRecentCallsView->mFilter->filterType() == LogsFilter::Missed );   
       
   261     QVERIFY( mRecentCallsView->mEffectInDissappearedPhase );
 
       
   262     QVERIFY( !mRecentCallsView->mListView->isVisible() ); // Hidden while in dissappeared state
 
       
   263     QVERIFY( !mRecentCallsView->mEmptyListLabel->isVisible() );
 
       
   264     mRecentCallsView->appearStarting();
 
       
   265     QVERIFY( !mRecentCallsView->mEffectInDissappearedPhase );
 
       
   266     QVERIFY( mRecentCallsView->mListView->isVisible() ); // Not anymore hidden as about to appear
 
       
   267     QVERIFY( !mRecentCallsView->mEmptyListLabel->isVisible() ); // Still hidden as list has data
 
   261     mRecentCallsView->appearByMovingComplete();
 
   268     mRecentCallsView->appearByMovingComplete();
 
   262     QVERIFY( mRecentCallsView->mListView->verticalScrollBarPolicy() != HbScrollArea::ScrollBarAlwaysOff );
 
   269     QVERIFY( mRecentCallsView->mListView->verticalScrollBarPolicy() != HbScrollArea::ScrollBarAlwaysOff );
 
   263     
   270     
   264     delete action;
 
   271     delete action;
 
   265     delete mRecentCallsView->mListView;
 
   272     delete mRecentCallsView->mListView;
 
   291     view->callKeyPressed();
 
   298     view->callKeyPressed();
 
   292     QVERIFY( LogsCall::lastCalledFunction() != "initiateCallback" );
 
   299     QVERIFY( LogsCall::lastCalledFunction() != "initiateCallback" );
 
   293     
   300     
   294     // No any item where to call
 
   301     // No any item where to call
 
   295     LogsCall::resetTestData();
 
   302     LogsCall::resetTestData();
 
   296     view->activated( false, QVariant(LogsServices::ViewAll) );
 
   303     view->activated( false, QVariant(XQService::LogsViewAll) );
 
   297     view->callKeyPressed();
 
   304     view->callKeyPressed();
 
   298     QVERIFY( LogsCall::lastCalledFunction() != "initiateCallback" );
 
   305     QVERIFY( LogsCall::lastCalledFunction() != "initiateCallback" );
 
   299     
   306     
   300     // Calling possible to list item
 
   307     // Calling possible to list item
 
   301     LogsCall::resetTestData();
 
   308     LogsCall::resetTestData();
 
   320     view->callKeyPressed();
 
   327     view->callKeyPressed();
 
   321     QVERIFY( LogsCall::isCallToNumberCalled() );
 
   328     QVERIFY( LogsCall::isCallToNumberCalled() );
 
   322     QCOMPARE( LogsCall::lastCalledNumber(), dial );
 
   329     QCOMPARE( LogsCall::lastCalledNumber(), dial );
 
   323     QVERIFY( LogsCall::lastCalledFunction() != "initiateCallback" );
 
   330     QVERIFY( LogsCall::lastCalledFunction() != "initiateCallback" );
 
   324     
   331     
   325     // Make sure that SS numbers are left untouched when calling
 
   332     // Make sure that number is converted to western digits before passing
 
       
   333     // forward
 
       
   334     HbStubHelper::stringUtilDigitConversion(true);
 
   326     LogsCall::resetTestData();
 
   335     LogsCall::resetTestData();
 
   327     dial = "*#7370#";
 
       
   328     view->mDialpad->editor().setText( dial );
 
   336     view->mDialpad->editor().setText( dial );
 
   329     view->callKeyPressed();
 
   337     view->callKeyPressed();
 
   330     QVERIFY( LogsCall::isCallToNumberCalled() );
 
   338     QVERIFY( LogsCall::isCallToNumberCalled() );
 
   331     QCOMPARE( LogsCall::lastCalledNumber(), dial );
 
   339     QCOMPARE( LogsCall::lastCalledNumber(), QString("conv") + dial );
 
   332     LogsCall::resetTestData();
 
   340     LogsCall::resetTestData();
 
   333     
   341     
   334     // Dialpad closed but contains text, call to first item in the list
 
   342     // Dialpad closed but contains text, call to first item in the list
 
   335     LogsCall::resetTestData();
 
   343     LogsCall::resetTestData();
 
   336     view->mDialpad->mIsOpen = false;
 
   344     view->mDialpad->mIsOpen = false;
 
   402 }
 
   410 }
 
   403 
   411 
   404 void UT_LogsRecentCallsView::testGestureEvent()
 
   412 void UT_LogsRecentCallsView::testGestureEvent()
 
   405 {
 
   413 {
 
   406     LogsRecentCallsView* view = mRepository->recentCallsView();
 
   414     LogsRecentCallsView* view = mRepository->recentCallsView();
 
   407     view->activated( false, QVariant(LogsServices::ViewCalled) );
 
   415     view->setLayoutDirection(Qt::LeftToRight);
 
   408     view->mCurrentView = LogsServices::ViewCalled;
 
   416     view->activated( false, QVariant(XQService::LogsViewCalled) );
 
   409     view->mAppearingView = LogsServices::ViewCalled;
 
   417     view->mCurrentView = XQService::LogsViewCalled;
 
       
   418     view->mAppearingView = XQService::LogsViewCalled;
 
   410 
   419 
   411     HbSwipeGesture* swipe = new HbSwipeGesture();
 
   420     HbSwipeGesture* swipe = new HbSwipeGesture();
 
   412     QList<QGesture*> list;
 
   421     QList<QGesture*> list;
 
   413     QGestureEvent event(list);
 
   422     QGestureEvent event(list);
 
   414     event.ignore(Qt::SwipeGesture);
 
   423     event.ignore(Qt::SwipeGesture);
 
   415 
   424 
   416     //no swipe gesture in event
 
   425     //no swipe gesture in event
 
   417     QVERIFY(!event.isAccepted(Qt::SwipeGesture));    
   426     QVERIFY(!event.isAccepted(Qt::SwipeGesture));    
   418     view->gestureEvent(&event);
 
   427     view->gestureEvent(&event);
 
   419     QVERIFY(!event.isAccepted(Qt::SwipeGesture));
 
   428     QVERIFY(!event.isAccepted(Qt::SwipeGesture));
 
   420     QCOMPARE(view->mCurrentView, LogsServices::ViewCalled);
 
   429     QCOMPARE(view->mCurrentView, XQService::LogsViewCalled);
 
   421     QCOMPARE(view->mAppearingView, LogsServices::ViewCalled);
 
   430     QCOMPARE(view->mAppearingView, XQService::LogsViewCalled);
 
   422     
   431     
   423     //swipe gesture in event, but gesture isn't finished
 
   432     //swipe gesture in event, but gesture isn't finished
 
   424     list.append(swipe);
 
   433     list.append(swipe);
 
   425     QGestureEvent event2(list);
 
   434     QGestureEvent event2(list);
 
   426     event2.ignore(Qt::SwipeGesture);
 
   435     event2.ignore(Qt::SwipeGesture);
 
   427     QVERIFY(!event2.isAccepted(Qt::SwipeGesture));
 
   436     QVERIFY(!event2.isAccepted(Qt::SwipeGesture));
 
   428     QVERIFY(swipe->state() != Qt::GestureFinished);
 
   437     QVERIFY(swipe->state() != Qt::GestureFinished);
 
   429     view->gestureEvent(&event2);
 
   438     view->gestureEvent(&event2);
 
   430     QVERIFY(!event2.isAccepted(Qt::SwipeGesture));
 
   439     QVERIFY(!event2.isAccepted(Qt::SwipeGesture));
 
   431     QCOMPARE(view->mCurrentView, LogsServices::ViewCalled);
 
   440     QCOMPARE(view->mCurrentView, XQService::LogsViewCalled);
 
   432     QCOMPARE(view->mAppearingView, LogsServices::ViewCalled);
 
   441     QCOMPARE(view->mAppearingView, XQService::LogsViewCalled);
 
   433     
   442     
   434     //swipe right
 
   443     //swipe right
 
       
   444     const int swipeAngleRight = 10;
 
   435     HbStubHelper::setGestureState(Qt::GestureFinished);
 
   445     HbStubHelper::setGestureState(Qt::GestureFinished);
 
   436     event2.setAccepted(Qt::SwipeGesture, false);
 
   446     event2.setAccepted(Qt::SwipeGesture, false);
 
   437     swipe->setSceneSwipeAngle(10);
 
   447     swipe->setSceneSwipeAngle(swipeAngleRight);
 
   438     view->gestureEvent(&event2);
 
   448     view->gestureEvent(&event2);
 
   439     QCOMPARE(view->mCurrentView, LogsServices::ViewCalled);
 
   449     QCOMPARE(view->mCurrentView, XQService::LogsViewCalled);
 
   440     QCOMPARE(view->mAppearingView, LogsServices::ViewAll );
 
   450     QCOMPARE(view->mAppearingView, XQService::LogsViewAll );
 
   441     QVERIFY( event2.isAccepted(Qt::SwipeGesture) );
 
   451     QVERIFY( event2.isAccepted(Qt::SwipeGesture) );
 
   442     
   452     
   443     //swipe left
 
   453     //swipe left
 
       
   454     const int swipeAngleLeft = 170;
 
   444     event2.setAccepted(Qt::SwipeGesture, false);
 
   455     event2.setAccepted(Qt::SwipeGesture, false);
 
   445     swipe->setSceneSwipeAngle(170);
 
   456     swipe->setSceneSwipeAngle(swipeAngleLeft);
 
   446     view->gestureEvent(&event2);
 
   457     view->gestureEvent(&event2);
 
   447     QCOMPARE(view->mCurrentView, LogsServices::ViewCalled);
 
   458     QCOMPARE(view->mCurrentView, XQService::LogsViewCalled);
 
   448     QCOMPARE(view->mAppearingView, LogsServices::ViewReceived);
 
   459     QCOMPARE(view->mAppearingView, XQService::LogsViewReceived);
 
   449     QVERIFY(event2.isAccepted(Qt::SwipeGesture));
 
   460     QVERIFY(event2.isAccepted(Qt::SwipeGesture));
 
   450     
   461     
   451     //swipe down, nothing happens
 
   462     //swipe down, nothing happens
 
   452     event2.setAccepted(Qt::SwipeGesture, false);
 
   463     event2.setAccepted(Qt::SwipeGesture, false);
 
   453     swipe->setSceneSwipeAngle(70);
 
   464     swipe->setSceneSwipeAngle(70);
 
   454     view->mAppearingView = view->mCurrentView;
 
   465     view->mAppearingView = view->mCurrentView;
 
   455     view->gestureEvent(&event2);
 
   466     view->gestureEvent(&event2);
 
   456     QCOMPARE(view->mCurrentView, LogsServices::ViewCalled);
 
   467     QCOMPARE(view->mCurrentView, XQService::LogsViewCalled);
 
   457     QCOMPARE(view->mAppearingView, LogsServices::ViewCalled);
 
   468     QCOMPARE(view->mAppearingView, XQService::LogsViewCalled);
 
   458     QVERIFY(!event2.isAccepted(Qt::SwipeGesture));
 
   469     QVERIFY(!event2.isAccepted(Qt::SwipeGesture));
 
       
   470     
       
   471     // Swipe directions are mirrored in right-to-left layout direction
 
       
   472     view->setLayoutDirection(Qt::RightToLeft);
 
       
   473     event2.setAccepted(Qt::SwipeGesture, false);
 
       
   474     swipe->setSceneSwipeAngle(swipeAngleLeft);
 
       
   475     view->gestureEvent(&event2);
 
       
   476     QCOMPARE(view->mCurrentView, XQService::LogsViewCalled);
 
       
   477     QCOMPARE(view->mAppearingView, XQService::LogsViewAll);
 
       
   478     QVERIFY(event2.isAccepted(Qt::SwipeGesture));
 
       
   479     
       
   480     event2.setAccepted(Qt::SwipeGesture, false);
 
       
   481     swipe->setSceneSwipeAngle(swipeAngleRight);
 
       
   482     view->gestureEvent(&event2);
 
       
   483     QCOMPARE(view->mCurrentView, XQService::LogsViewCalled);
 
       
   484     QCOMPARE(view->mAppearingView, XQService::LogsViewReceived);
 
       
   485     QVERIFY(event2.isAccepted(Qt::SwipeGesture));
 
       
   486     
       
   487     qDeleteAll(list);
 
   459 }
 
   488 }
 
   460 
   489 
   461 void UT_LogsRecentCallsView::testViewChangeByFlicking()
 
   490 void UT_LogsRecentCallsView::testViewChangeByFlicking()
 
   462 {
 
   491 {
 
       
   492     qApp->setLayoutDirection(Qt::LeftToRight);
 
       
   493     
   463     // At leftmost list, moving to left not possible
 
   494     // At leftmost list, moving to left not possible
 
   464     // List not empty, starting list animation
 
   495     // List not empty, starting list animation
 
   465     LogsRecentCallsView* view = mRepository->recentCallsView();
 
   496     LogsRecentCallsView* view = mRepository->recentCallsView();
 
   466     view->activated( false, QVariant(LogsServices::ViewAll) );
 
   497     view->activated( false, QVariant(XQService::LogsViewAll) );
 
   467     view->mCurrentView = LogsServices::ViewAll;
 
   498     view->mCurrentView = XQService::LogsViewAll;
 
   468     QVERIFY(view->model() && view->model()->rowCount()>0);
 
   499     QVERIFY(view->model() && view->model()->rowCount()>0);
 
   469     view->rightFlick();
 
   500     view->moveBackwardInLists();
 
   470     QVERIFY(view->mCurrentView == LogsServices::ViewAll);
 
   501     QVERIFY(view->mCurrentView == XQService::LogsViewAll);
 
   471     QVERIFY(view->mAppearingView == LogsServices::ViewAll);
 
   502     QVERIFY(view->mAppearingView == XQService::LogsViewAll);
 
   472     QVERIFY(view->mEffectHandler->mItemMoveNotPossibleAnimationStart->targetObject()
 
   503     QVERIFY(view->mEffectHandler->mItemMoveNotPossibleAnimationStart->targetObject()
 
   473             == view->mListView);
 
   504             == view->mListView);
 
   474     
   505     
   475     // Moving left not possible, list empty, starting empty label animation
 
   506     // Moving left not possible, list empty, starting empty label animation
 
   476     delete view->mFilter;
 
   507     delete view->mFilter;
 
   477     view->mFilter = 0;
 
   508     view->mFilter = 0;
 
   478     QVERIFY(!view->model());
 
   509     QVERIFY(!view->model());
 
   479     view->rightFlick();
 
   510     view->moveBackwardInLists();
 
   480     QVERIFY(view->mCurrentView == LogsServices::ViewAll);
 
   511     QVERIFY(view->mCurrentView == XQService::LogsViewAll);
 
   481     QVERIFY(view->mAppearingView == LogsServices::ViewAll);
 
   512     QVERIFY(view->mAppearingView == XQService::LogsViewAll);
 
   482     QVERIFY(view->mEffectHandler->mItemMoveNotPossibleAnimationStart->targetObject()
 
   513     QVERIFY(view->mEffectHandler->mItemMoveNotPossibleAnimationStart->targetObject()
 
   483             == view->mEmptyListLabel);
 
   514             == view->mEmptyListLabel);
 
   484     
   515     
   485     // Moving to right possible
 
   516     // Moving to right possible
 
   486     view->leftFlick();
 
   517     view->moveForwardInLists();
 
   487     QVERIFY(view->mCurrentView == LogsServices::ViewAll);
 
   518     QVERIFY(view->mCurrentView == XQService::LogsViewAll);
 
   488     QVERIFY(view->mAppearingView == LogsServices::ViewCalled);
 
   519     QVERIFY(view->mAppearingView == XQService::LogsViewCalled);
 
       
   520     QVERIFY(!view->mMoveLeftInList);
 
   489     
   521     
   490     // At rightmost list, moving further not possible
 
   522     // At rightmost list, moving further not possible
 
   491     // List empty, starting empty label animation
 
   523     // List empty, starting empty label animation
 
   492     view->mCurrentView = LogsServices::ViewMissed;
 
   524     view->mCurrentView = XQService::LogsViewMissed;
 
   493     QVERIFY(!view->model());
 
   525     QVERIFY(!view->model());
 
   494     view->leftFlick();
 
   526     view->moveForwardInLists();
 
   495     QVERIFY(view->mCurrentView == LogsServices::ViewMissed);
 
   527     QVERIFY(view->mCurrentView == XQService::LogsViewMissed);
 
   496     QVERIFY(view->mAppearingView == LogsServices::ViewCalled);
 
   528     QVERIFY(view->mAppearingView == XQService::LogsViewCalled);
 
   497     QVERIFY(view->mEffectHandler->mItemMoveNotPossibleAnimationStart->targetObject()
 
   529     QVERIFY(view->mEffectHandler->mItemMoveNotPossibleAnimationStart->targetObject()
 
   498                 == view->mEmptyListLabel);
 
   530                 == view->mEmptyListLabel);
 
   499 
   531 
   500     // Moving right not possible, list not empty, starting list animation
 
   532     // Moving right not possible, list not empty, starting list animation
 
   501     LogsModel model;
 
   533     LogsModel model;
 
   502     view->mFilter = new LogsFilter();
 
   534     view->mFilter = new LogsFilter();
 
   503     view->mFilter->setSourceModel(&model);
 
   535     view->mFilter->setSourceModel(&model);
 
   504     view->leftFlick();
 
   536     view->moveForwardInLists();
 
   505     QVERIFY(view->mCurrentView == LogsServices::ViewMissed);
 
   537     QVERIFY(view->mCurrentView == XQService::LogsViewMissed);
 
   506     QVERIFY(view->mAppearingView == LogsServices::ViewCalled);
 
   538     QVERIFY(view->mAppearingView == XQService::LogsViewCalled);
 
   507     QVERIFY(view->mEffectHandler->mItemMoveNotPossibleAnimationStart->targetObject()
 
   539     QVERIFY(view->mEffectHandler->mItemMoveNotPossibleAnimationStart->targetObject()
 
   508                 == view->mListView);
 
   540                 == view->mListView);
 
   509     
   541     
   510     // Now moving to left is possible
 
   542     // Now moving to left is possible
 
   511     view->rightFlick();
 
   543     view->moveBackwardInLists();
 
   512     QVERIFY(view->mCurrentView == LogsServices::ViewMissed);
 
   544     QVERIFY(view->mCurrentView == XQService::LogsViewMissed);
 
   513     QVERIFY(view->mAppearingView == LogsServices::ViewReceived);
 
   545     QVERIFY(view->mAppearingView == XQService::LogsViewReceived);
 
       
   546     QVERIFY(view->mMoveLeftInList);
 
   514     
   547     
   515     // Simulate effect completion which activates new view
 
   548     // Simulate effect completion which activates new view
 
   516     view->dissappearByFadingComplete();
 
   549     view->dissappearByFadingComplete();
 
   517     QVERIFY( view->mViewName->heading() 
   550     QVERIFY( view->mViewName->heading() 
   518              == view->mTitleMap.value(view->mConversionMap.value(LogsServices::ViewReceived)) );
 
   551              == view->mTitleMap.value(view->mConversionMap.value(XQService::LogsViewReceived)) );
 
   519     
   552     
   520     view->dissappearByMovingComplete();
 
   553     view->dissappearByMovingComplete();
 
   521     QVERIFY(view->mCurrentView == LogsServices::ViewReceived);
 
   554     QVERIFY(view->mCurrentView == XQService::LogsViewReceived);
 
   522     QVERIFY(view->mAppearingView == LogsServices::ViewReceived);
 
   555     QVERIFY(view->mAppearingView == XQService::LogsViewReceived);
 
   523     
   556     
   524     // If view would be already what expected, nothing happens
 
   557     // If view would be already what expected, nothing happens
 
   525     view->dissappearByMovingComplete();
 
   558     view->dissappearByMovingComplete();
 
   526     QVERIFY(view->mCurrentView == LogsServices::ViewReceived);
 
   559     QVERIFY(view->mCurrentView == XQService::LogsViewReceived);
 
   527     QVERIFY(view->mAppearingView == LogsServices::ViewReceived);
 
   560     QVERIFY(view->mAppearingView == XQService::LogsViewReceived);
 
       
   561     
       
   562     // Check that moving direction is mirrored in RTL layout dir
 
       
   563     view->setLayoutDirection(Qt::RightToLeft);
 
       
   564     view->mCurrentView = XQService::LogsViewAll;
 
       
   565     view->moveForwardInLists();
 
       
   566     QVERIFY(view->mCurrentView == XQService::LogsViewAll);
 
       
   567     QVERIFY(view->mAppearingView == XQService::LogsViewCalled);
 
       
   568     QVERIFY(view->mMoveLeftInList);
 
       
   569     view->mCurrentView = XQService::LogsViewCalled;
 
       
   570     view->moveBackwardInLists();
 
       
   571     QVERIFY(view->mCurrentView == XQService::LogsViewCalled);
 
       
   572     QVERIFY(view->mAppearingView == XQService::LogsViewAll);
 
       
   573     QVERIFY(!view->mMoveLeftInList);
 
       
   574     
       
   575     
   528 }
 
   576 }
 
   529 
   577 
   530 
   578 
   531 void UT_LogsRecentCallsView::testModel()
 
   579 void UT_LogsRecentCallsView::testModel()
 
   532 {
 
   580 {
 
   533     LogsRecentCallsView* view = mRepository->recentCallsView();
 
   581     LogsRecentCallsView* view = mRepository->recentCallsView();
 
   534     view->activated(false, QVariant(LogsServices::ViewAll));
 
   582     view->activated(false, QVariant(XQService::LogsViewAll));
 
   535     QVERIFY( view->mFilter );
 
   583     QVERIFY( view->mFilter );
 
   536     QVERIFY( view->model() == view->mFilter );
 
   584     QVERIFY( view->model() == view->mFilter );
 
   537 }
 
   585 }
 
   538 
   586 
   539 void UT_LogsRecentCallsView::testShowListItemMenu()
 
   587 void UT_LogsRecentCallsView::testShowListItemMenu()
 
   633     view->activateEmptyListIndicator(view->mFilter);
 
   681     view->activateEmptyListIndicator(view->mFilter);
 
   634     QVERIFY( view->mEmptyListLabel );
 
   682     QVERIFY( view->mEmptyListLabel );
 
   635     QVERIFY( view->mEmptyListLabel->isVisible() );
 
   683     QVERIFY( view->mEmptyListLabel->isVisible() );
 
   636     QVERIFY(action && !action->isVisible());
 
   684     QVERIFY(action && !action->isVisible());
 
   637     
   685     
       
   686     // Empty model but effect in dissapeared state, label is set invisible
 
       
   687     view->mEffectInDissappearedPhase = true;
 
       
   688     view->activateEmptyListIndicator(view->mFilter);
 
       
   689     QVERIFY( view->mEmptyListLabel );
 
       
   690     QVERIFY( !view->mEmptyListLabel->isVisible() );
 
       
   691     
   638     // Model has items, label is set invisible
 
   692     // Model has items, label is set invisible
 
       
   693     view->mEffectInDissappearedPhase = false;
 
   639     LogsModel model;
 
   694     LogsModel model;
 
   640     view->mFilter->setSourceModel(&model);
 
   695     view->mFilter->setSourceModel(&model);
 
   641     view->activateEmptyListIndicator(view->mFilter);
 
   696     view->activateEmptyListIndicator(view->mFilter);
 
   642     QVERIFY( view->mEmptyListLabel );
 
   697     QVERIFY( view->mEmptyListLabel );
 
   643     QVERIFY( !view->mEmptyListLabel->isVisible() );
 
   698     QVERIFY( !view->mEmptyListLabel->isVisible() );
 
   872 }
 
   927 }
 
   873 
   928 
   874 void UT_LogsRecentCallsView::testDialpadOpened()
 
   929 void UT_LogsRecentCallsView::testDialpadOpened()
 
   875 {
 
   930 {
 
   876     mRepository->recentCallsView();
 
   931     mRepository->recentCallsView();
 
   877     mRecentCallsView->activated( false, QVariant(LogsServices::ViewAll) );
 
   932     mRecentCallsView->activated( false, QVariant(XQService::LogsViewAll) );
 
   878         
   933         
   879     // If contact search is disabled, opening dialpad containing input
 
   934     // If contact search is disabled, opening dialpad containing input
 
   880     // does not cause going to matches view
 
   935     // does not cause going to matches view
 
   881     mViewManager->reset();
 
   936     mViewManager->reset();
 
   882     mRecentCallsView->mDialpad->mIsOpen = true;
 
   937     mRecentCallsView->mDialpad->mIsOpen = true;
 
   902 void UT_LogsRecentCallsView::testSaveActivity()
 
   957 void UT_LogsRecentCallsView::testSaveActivity()
 
   903 {
 
   958 {
 
   904     QByteArray serializedActivity;
 
   959     QByteArray serializedActivity;
 
   905     QDataStream stream(&serializedActivity, QIODevice::WriteOnly | QIODevice::Append);
 
   960     QDataStream stream(&serializedActivity, QIODevice::WriteOnly | QIODevice::Append);
 
   906     QVariantHash metaData;
 
   961     QVariantHash metaData;
 
   907     mRecentCallsView->mCurrentView = LogsServices::ViewMissed;
 
   962     mRecentCallsView->mCurrentView = XQService::LogsViewMissed;
 
   908     QVERIFY( mRecentCallsView->saveActivity(stream, metaData) == QString(logsActivityIdViewMissed) );
 
   963     QVERIFY( mRecentCallsView->saveActivity(stream, metaData) == QString(logsActivityIdViewMissed) );
 
   909     mRecentCallsView->mCurrentView = LogsServices::ViewAll;
 
   964     mRecentCallsView->mCurrentView = XQService::LogsViewAll;
 
   910     QVERIFY( mRecentCallsView->saveActivity(stream, metaData) == QString(logsActivityIdViewRecent) );
 
   965     QVERIFY( mRecentCallsView->saveActivity(stream, metaData) == QString(logsActivityIdViewRecent) );
 
   911 
   966 
   912 }
 
   967 }
 
   913 
   968 
   914 void UT_LogsRecentCallsView::testLoadActivity()
 
   969 void UT_LogsRecentCallsView::testLoadActivity()
 
   916     QByteArray serializedActivity;
 
   971     QByteArray serializedActivity;
 
   917     QDataStream stream(&serializedActivity, QIODevice::ReadOnly);
 
   972     QDataStream stream(&serializedActivity, QIODevice::ReadOnly);
 
   918     QVariantHash metaData;
 
   973     QVariantHash metaData;
 
   919     QVariant args = mRecentCallsView->loadActivity(QString(logsActivityIdViewCalled), stream, metaData);
 
   974     QVariant args = mRecentCallsView->loadActivity(QString(logsActivityIdViewCalled), stream, metaData);
 
   920     QVERIFY( !args.isNull() );
 
   975     QVERIFY( !args.isNull() );
 
   921     QVERIFY( args.toInt() == LogsServices::ViewCalled );
 
   976     QVERIFY( args.toInt() == XQService::LogsViewCalled );
 
   922     QVariant args2 = mRecentCallsView->loadActivity(QString(logsActivityIdViewMissed), stream, metaData);
 
   977     QVariant args2 = mRecentCallsView->loadActivity(QString(logsActivityIdViewMissed), stream, metaData);
 
   923     QVERIFY( !args2.isNull() );
 
   978     QVERIFY( !args2.isNull() );
 
   924     QVERIFY( args2.toInt() == LogsServices::ViewMissed);
 
   979     QVERIFY( args2.toInt() == XQService::LogsViewMissed);
 
   925 }
 
   980 }
 
       
   981 
       
   982 
       
   983 void UT_LogsRecentCallsView::testEventFilter()
 
       
   984 {
 
       
   985     // Non-gesture event 
       
   986     HbLabel object;
 
       
   987     QEvent dummyEvent(QEvent::Show);
 
       
   988     QVERIFY( !mRecentCallsView->eventFilter(&object, &dummyEvent) );
 
       
   989     
       
   990     // Swipe gesture event
 
       
   991     QList<QGesture*> list;
 
       
   992     QGestureEvent event(list);
 
       
   993     QSwipeGesture* swipe = new QSwipeGesture();
 
       
   994     list.append(swipe);
 
       
   995     QVERIFY( !mRecentCallsView->eventFilter(&object, &event) );
 
       
   996     QVERIFY( !swipe->property("horizontallyRestricted").isValid() );
 
       
   997     
       
   998     // Tap gesture on some other object (not mListView)
 
       
   999     QTapGesture* tap = new QTapGesture();
 
       
  1000     list.append(tap);
 
       
  1001     QGestureEvent event2(list);
 
       
  1002     HbStubHelper::setGestureState(Qt::GestureStarted);
 
       
  1003     QVERIFY( !mRecentCallsView->eventFilter(&object, &event2) );
 
       
  1004     QVERIFY( !tap->property("horizontallyRestricted").isValid() );
 
       
  1005         
       
  1006     //Tap gesture on list item => property is set
 
       
  1007     mRecentCallsView->mListView = new HbListView();
 
       
  1008     mRepository->model()->mTextData.append("testdata");
 
       
  1009     HbAbstractViewItem* viewItem = mRecentCallsView->mListView->currentViewItem();
 
       
  1010     QVERIFY( !mRecentCallsView->eventFilter(viewItem, &event2) );
 
       
  1011     QVERIFY( tap->property("horizontallyRestricted").isValid() );    
       
  1012     
       
  1013     qDeleteAll(list);
 
       
  1014     delete mRecentCallsView->mListView;
 
       
  1015     mRecentCallsView->mListView = 0;
 
       
  1016 }
FCL/sf/app/recents